<?xml version="1.0" encoding="UTF-8"?>
<!-- Version 471 -->
<!-- Copyright (c) 2003-2006 eBay Inc. All Rights Reserved. -->
<wsdl:definitions 
	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
	xmlns:xs="http://www.w3.org/2001/XMLSchema" 
	xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" 
	xmlns:ns="urn:ebay:apis:eBLBaseComponents" 
	xmlns="urn:ebay:apis:eBLBaseComponents"
	targetNamespace="urn:ebay:apis:eBLBaseComponents">
	<wsdl:types>
		<xs:schema targetNamespace="urn:ebay:apis:eBLBaseComponents"  
		xmlns:ns="urn:ebay:apis:eBLBaseComponents" 
		xmlns="urn:ebay:apis:eBLBaseComponents"
		xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">

	<!-- Custom Security header element-->
	<xs:element name="RequesterCredentials" type="ns:CustomSecurityHeaderType">
		<xs:annotation>
			<xs:documentation>
				Authentication information for the user on whose behalf the
				application is making the request. Only registered eBay users are
				allowed to make API calls. To verify that a user is registered,
				your application needs to pass a user-specific value called an
				"authentication token" in the request. This is equivalent to
				signing in on the eBay Web site. As API calls do not pass session
				information, you need to pass the user's authentication token every
				time you invoke a call on their behalf. All calls require an
				authentication token, except the calls you use to retrieve a token
				in the first place. (For such calls, you use the eBay member's
				username and password instead.)
			</xs:documentation>
			<xs:appinfo>
				<CallInfo>
					<AllCalls/>
					<RequiredInput>Yes</RequiredInput>
				</CallInfo>
			</xs:appinfo>
		</xs:annotation>
	</xs:element>
		<!--  Call: AddDispute -->
	<xs:element name="AddDisputeRequest" type="ns:AddDisputeRequestType"/>
	<xs:complexType name="AddDisputeRequestType">
		<xs:annotation>
			<xs:documentation>
				Allows a seller to create a new Unpaid Item dispute. Can only be used by
				the seller at least 7 days after the transaction is created, unless the
				buyer is no longer a registered eBay user or has requested shipment to a
				country the seller does not ship to. A buyer creates an Item Not
				Received dispute on the eBay site.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to use an item ID and transaction ID to create a new Unpaid Item dispute.  
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="DisputeExplanation" type="ns:DisputeExplanationCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An explanation of the dispute that supplements the
								DisputeReason. The allowed value depends on the value of
								DisputeReason.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisputeReason" type="ns:DisputeReasonCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The top-level reason for the Unpaid Item Dispute.
								DisputeReasonCodeType has several possible values. However, only
								BuyerHasNotPaid and TransactionMutuallyCanceled apply to
								AddDispute--you can only use AddDisputeCall to create Unpaid
								Item disputes.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The eBay ID of the item in dispute, an item which has been
								sold but not yet paid for.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The eBay ID of a transaction, created when the buyer committed
								to purchasing the item. A transaction ID is unique to the item
								but not across the entire eBay site. The transaction ID must be
								combined with an item ID to uniquely identify an item.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>AddDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddDispute -->
	<xs:element name="AddDisputeResponse" type="ns:AddDisputeResponseType"/>
	<xs:complexType name="AddDisputeResponseType">
		<xs:annotation>
			<xs:documentation>
				Returned after calling AddDisputeRequest. The response confirms that
				the Unpaid Item dispute was successfully created.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="DisputeID" type="ns:DisputeIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
	    					The unique identifier of the Unpaid Item dispute.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDispute</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddDisputeResponse -->
	<xs:element name="AddDisputeResponseRequest" type="ns:AddDisputeResponseRequestType"/>
	<xs:complexType name="AddDisputeResponseRequestType">
		<xs:annotation>
			<xs:documentation>
				Allows a seller to respond to an Unpaid Item or Item Not Received dispute.
				The response can add a comment or close the dispute.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Adds a response or comment to a dispute, or closes a dispute.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="DisputeID" type="ns:DisputeIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier of the dispute,
								returned when the dispute was created.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDisputeResponse</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MessageText" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The text of a comment or response being posted
								to the dispute. Required when DisputeActivity is
								SellerAddInformation, SellerComment, or
								SellerPaymentNotReceived; otherwise, optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDisputeResponse</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisputeActivity" type="ns:DisputeActivityCodeType"  minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The type of activity the seller is taking on the dispute.
								The allowed value is determined by the current value of
								DisputeState, returned by GetDispute or GetUserDisputes.
								Some values are for Unpaid Item disputes and some are for Item
								Not Received disputes.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDisputeResponse</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingCarrierUsed" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The shipping carrier used for the item in dispute. Required if DisputeActivity
								is SellerShippedItem; otherwise, optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDisputeResponse</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShipmentTrackNumber" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The shipper's tracking number for the item being shipped. Required
								if DisputeActivity is SellerShippedItem; otherwise, optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDisputeResponse</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The date the item under dispute was shipped. Required if DisputeActivity
								is SellerShippedItem; otherwise, optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddDisputeResponse</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddDisputeResponse -->
	<xs:element name="AddDisputeResponseResponse" type="ns:AddDisputeResponseResponseType"/>
	<xs:complexType name="AddDisputeResponseResponseType">
		<xs:annotation>
			<xs:documentation>
				Returned after taking an action on a dispute with AddDisputeResponseRequest.
				Includes the status of the request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddItem -->
	<xs:element name="AddItemRequest" type="ns:AddItemRequestType"/>
	<xs:complexType name="AddItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Defines a single new item and lists it on a specified eBay site.
				To list multiple new items, execute AddItem once for each item,
				with a new item definition each time.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Sends data defining a new item (specified by a seller) to eBay,
						where it becomes a new listing. Returns the item ID for the new listing
						and estimates fees the seller will incur for the listing
						(not including the Final Value Fee, which cannot be calculated until the item is sold). 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType"  minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements hold the values that define the new item. Item is a
								required input.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								This field will be removed from the schema
								in a future release. Recommended usage as of release 439 varies for
								eBay.com listings and Half.com listings.
								&lt;br&gt;&lt;br&gt;
								For eBay.com listings:
								As of release 439, this field can still be passed in, but we recommend
								that you update your applications to use the ExternalProductID field
								defined on the item instead (i.e., Item.ExternalProductID).
								If you specify both Item.ExternalProductID and this field in the same
								request, eBay uses the value in Item.ExternalProductID and ignores the
								value in this field. See Item.ExternalProductID for information on using
								an external ID for eBay.com listings.
								&lt;br&gt;&lt;br&gt;
								For Half.com listings:
								As of release 439, this field is required for Half.com listings.
								Causes Half.com to list the item with Pre-filled Item Information based
								on an ISBN value or other supported external ID, plus other meta-data
								that you specify. See the eBay Web Services guide for information about
								listing to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
									<TagStatus>Deprecated</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddItem -->
	<xs:element name="AddItemResponse" type="ns:AddItemResponseType"/>
	<xs:complexType name="AddItemResponseType">
		<xs:annotation>
			<xs:documentation>
          Returns the item ID and the estimated fees for the new listing, as well as
          the start and end times of the listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID for the new listing.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Starting date and time for the new listing.
								Also returned for Half.com (for Half.com, the start time is always the time the item was listed).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Date and time when the new listing ends. This is the starting time
								plus the listing duration.
								Also returned for Half.com, but for Half.com the actual end time is GTC
								(not the end time returned in the response).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements contain the estimated listing fees for the new item listing.
								The fees do not include the Final Value Fee (FVF), which cannot be determined
								until an item is sold.
								Also returned for Half.com, but the values are not applicable to Half.com listings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the primary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID you passed in PrimaryCategory was mapped to a new ID by eBay.
								If the primary category has not changed or it has expired with no replacement,
								CategoryID does not return a value.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>AddItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category2ID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the secondary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID you passed in SecondaryCategory was mapped to a new ID by eBay.
								If the secondary category has not changed or it has expired with no replacement,
								Category2ID does not return a value.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>AddItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddLiveAuctionItem -->
	<xs:element name="AddLiveAuctionItemRequest" type="ns:AddLiveAuctionItemRequestType"/>
	<xs:complexType name="AddLiveAuctionItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Lists a lot item on the eBay Live Auctions site. The lot item will
				also be visible to users who search and browse the US eBay.com
				site. Only authorized eBay Live Auctions sellers can list lot
				items.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Available to eBay Live Auctions sellers. Sends data defining a single new lot item
						to the eBay Live Auctions site, where it becomes a new lot in a seller's Live Auction catalog.
						The listing also appears on the main eBay site. As in the case of AddItem,
						the data returned includes an item ID for the new listing and estimated fees,
						not including the Final Value Fee. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType"  minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the values that define the new lot item.
								Item is a required input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddLiveAuctionItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddLiveAuctionItem -->
	<xs:element name="AddLiveAuctionItemResponse" type="ns:AddLiveAuctionItemResponseType"/>
	<xs:complexType name="AddLiveAuctionItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the item ID and the estimated fees for the new lot item listing,
				as well as the state of the lot item (e.g., categories that changed).
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The item ID of the lot.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddLiveAuctionItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements contain the estimated listing fees for the new item listing.
								The fees do not include the Final Value Fee (FVF), which cannot be determined
								until an item is sold.
								For consistency in the response, the call returns the same kinds of fees
								as other listing calls, but some fees are not applicable to eBay Live Auctions listings.
								See "Fees Resulting from Listing an Item" in the eBay Web Services guide
								for information about fees.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddLiveAuctionItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the primary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID you passed in PrimaryCategory was mapped to a new ID by eBay.
								If the primary category has not changed or it has expired with no replacement,
								CategoryID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>AddLiveAuctionItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category2ID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the secondary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID you passed in SecondaryCategory was mapped to a new ID by eBay.
								If the secondary category has not changed or it has expired with no replacement,
								Category2ID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>AddLiveAuctionItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessage -->
	<xs:element name="AddMemberMessageRequest" type="ns:AddMemberMessageRequestType"/>
	<xs:complexType name="AddMemberMessageRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to respond to eBay users who have asked
				questions about an active item listings. To be deprecated in Oct 2006.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to respond to eBay users who have asked
						questions about an active item listing.
						To be deprecated in Oct 2006. Use AddMemberMessageRTQ instead.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique ID of the item about which
								the question was asked. Required input
								for AddMemberMessage MessageType = ResponseToASQQuestion.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddMemberMessage</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MemberMessage" type="ns:MemberMessageType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The message itself.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessage</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessage -->
	<xs:element name="AddMemberMessageResponse" type="ns:AddMemberMessageResponseType"/>
	<xs:complexType name="AddMemberMessageResponseType">
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessageAAQToPartner -->
	<xs:element name="AddMemberMessageAAQToPartnerRequest" type="ns:AddMemberMessageAAQToPartnerRequestType"/>
	<xs:complexType name="AddMemberMessageAAQToPartnerRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a buyer and seller in a transactional relationship to send messages to each other
				within 90 days of the creation of the transaction.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a buyer and seller in a transactional relationship to
						send messages to each other's My Messages Inboxes within 90 days of the creation of
						the transaction. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique ID of the item about which the question was asked.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessageAAQToPartner</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MemberMessage" type="ns:MemberMessageType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The message itself.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessageAAQToPartner</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessageAAQToPartner -->
	<xs:element name="AddMemberMessageAAQToPartnerResponse" type="ns:AddMemberMessageAAQToPartnerResponseType"/>
	<xs:complexType name="AddMemberMessageAAQToPartnerResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to AddMemberMessageAAQToPartner request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessageRTQ -->
	<xs:element name="AddMemberMessageRTQRequest" type="ns:AddMemberMessageRTQRequestType"/>
	<xs:complexType name="AddMemberMessageRTQRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to reply to a question about an active item listing.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to reply to a question about an active item listing. The reply is sent
						to the user's My Messages inbox.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique ID of the item about which
								the question was asked.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessageRTQ</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MemberMessage" type="ns:MemberMessageType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The message itself.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessageRTQ</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessageRTQ -->
	<xs:element name="AddMemberMessageRTQResponse" type="ns:AddMemberMessageRTQResponseType"/>
	<xs:complexType name="AddMemberMessageRTQResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to AddMemberMessageRTQ request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessagesAAQToBidder -->
	<xs:element name="AddMemberMessagesAAQToBidderRequest" type="ns:AddMemberMessagesAAQToBidderRequestType"/>
	<xs:complexType name="AddMemberMessagesAAQToBidderRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to send up to 10 messages to bidders and
				users who have made offers (via Best Offer) during an
				active listing.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to send up to 10 messages to bidders and
						users who have made offers (via Best Offer) during an
						active listing. Messages to a user appear in the user's My Messages inbox. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AddMemberMessagesAAQToBidderRequestContainer" type="ns:AddMemberMessagesAAQToBidderRequestContainerType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
							Allows a seller to send up to 10 messages to
							bidders and users who have made offers (via Best
							Offer) during an active listing.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessagesAAQToBidder</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddMemberMessagesAAQToBidder -->
<!-- auto-generated by API Schema Generation Tool-->
	<xs:element name="AddMemberMessagesAAQToBidderResponse" type="ns:AddMemberMessagesAAQToBidderResponseType"/>
	<xs:complexType name="AddMemberMessagesAAQToBidderResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the response information.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="AddMemberMessagesAAQToBidderResponseContainer" type="ns:AddMemberMessagesAAQToBidderResponseContainerType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Contains the response information.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddMemberMessagesAAQToBidder</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddOrder -->
	<xs:element name="AddOrderRequest" type="ns:AddOrderRequestType"/>
	<xs:complexType name="AddOrderRequestType">
		<xs:annotation>
			<xs:documentation>
				Combines two or more transactions into a single order. A transaction is
				the commitment by a buyer to purchase an item. On a successful call to
				AddOrder, the multiple transactions are combined into a single order.
				&lt;br&gt;&lt;br&gt;
				We strongly recommend that you avoid mixing digital and non-digital listings in the same order.
				(In the future, AddOrder may enforce this recommendation.)
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Combines two or more transactions into a single order. The order has a unique identifier and the buyer can make a single payment for purchases. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Order" type="ns:OrderType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The order that is being created.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddOrder</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddOrder -->
	<xs:element name="AddOrderResponse" type="ns:AddOrderResponseType"/>
	<xs:complexType name="AddOrderResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns a unique identifier for the order. A buyer may make a single
				payment to purchase all of the item transactions that are included
				in the order.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="OrderID" type="ns:OrderIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier for the order.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddOrder</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CreatedTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The date and time the order was created.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddOrder</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddSecondChanceItem -->
	<xs:element name="AddSecondChanceItemRequest" type="ns:AddSecondChanceItemRequestType"/>
	<xs:complexType name="AddSecondChanceItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Creates a new Second Chance Offer listing for an item to one of that item's
				non-winning bidders.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Creates a new Second Chance Offer (that is, an offer for an unsold item) to a non-winning bidder.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="RecipientBidderUserID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the bidder from the original,
								ended listing to whom the seller is extending
								the second chance offer. Specify only one
								RecipientBidderUserID per call. If multiple
								users are specified (each in a
								RecipientBidderUserID node), only the last one
								specified receives the offer.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BuyItNowPrice" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the amount the offer recipient
								must pay to purchase the item from the second
								chance offer listing. Use only when the original
								item was an eBay Motors (or in some categories
								on U.S. and international sites for high-priced
								items, such as items in many U.S. and Canada
								Business and Industrial categories) and it ended
								unsold because the reserve price was not met.
								Call fails with an error for any other item
								conditions.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CopyEmailToSeller" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								Specifies whether to send a
								copy to the seller of the second chance offer
								notification email that goes to the recipient
								user. With 457, the seller always receives a
								copy of the email, and this tag is ignored as
								input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
									<TagStatus>Obsolete</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Duration" type="ns:SecondChanceOfferDurationCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the length of time the second
								chance offer listing will be active. The
								recipient bidder has that much time to
								purchase the item or the listing expires.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the item ID for the original,
								ended listing from which the second chance
								offer item comes. A new ItemID is returned for
								the second chance offer item.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Site" type="ns:SiteCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Reserved for internal or future use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<NoCalls/>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerMessage" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Message content. Cannot contain HTML,
								asterisks, or quotes. This content is
								included in the second chance offer email sent
								to the recipient, which can be retrieved with
								GetMyMessages.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>1000</MaxLength>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddSecondChanceItem -->
	<xs:element name="AddSecondChanceItemResponse" type="ns:AddSecondChanceItemResponseType"/>
	<xs:complexType name="AddSecondChanceItemResponseType">
		<xs:annotation>
			<xs:documentation>
				AddSecondChanceItem response for a new Second Chance
				Offer listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the listing fees for the new second
								chance offer listing.
							</xs:documentation>
							<xs:appinfo>
								<SeeLink>
									<Title>Value-Added Tax (VAT)</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/B2BandVAT-Value-Added_Tax_(VAT).html</URL>
								</SeeLink>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the item ID for the new second chance
								offer listing. Different from the original ItemID passed in the request.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the date and time when the the new
								second chance offer listing became active and
								the recipient user could purchase the item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the date and time when the second
								chance offer listing expires, at which time
								the listing ends (if the recipient user does
								not purchase the item first).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddToItemDescription -->
	<xs:element name="AddToItemDescriptionRequest" type="ns:AddToItemDescriptionRequestType"/>
	<xs:complexType name="AddToItemDescriptionRequestType">
		<xs:annotation>
			<xs:documentation>
				Adds text to the end of the description section of an item listing.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Adds text to the end of the description section of an item listing.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID that identifies the target item listing, the description
								of which is appended with the text specified in Description.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddToItemDescription</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Description" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the text to append to the end of the listings description.
								Text appended to a listing's description must abide by the rules
								applicable to this data (such as no JavaScript) as is the case when
								first listing the item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddToItemDescription</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddToItemDescription -->
	<xs:element name="AddToItemDescriptionResponse" type="ns:AddToItemDescriptionResponseType"/>
	<xs:complexType name="AddToItemDescriptionResponseType">
		<xs:annotation>
			<xs:documentation>
				Indicates the success or failure of the attempt to add text to the end of the 
				description section of an item listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddToWatchList -->
	<xs:element name="AddToWatchListRequest" type="ns:AddToWatchListRequestType"/>
	<xs:complexType name="AddToWatchListRequestType">
		<xs:annotation>
			<xs:documentation>
				Adds one or more items to the user's My eBay watch list.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Adds one or more items to the user's My eBay watch list.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The ItemID of the item that is to be added
								to the watch list. The item must be a currently
								active item, and the total number of items in
								the watchlist (after the items in the request
								have been added) cannot exceed the maximum
								allowed number of watch list items.
								One or more ItemIDs can be specified, each in
								its own ItemID container. A separate error node
								will be returned for each item that fails.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>AddToWatchList</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddToWatchList -->
	<xs:element name="AddToWatchListResponse" type="ns:AddToWatchListResponseType"/>
	<xs:complexType name="AddToWatchListResponseType">
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="WatchListCount" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The number of items in the user's watch list (after those specified
								in the call request have been added)
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddToWatchList</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WatchListMaximum" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The maximum number of items allowed in watch lists. Currently this
								value is the same for all sites and all users.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddToWatchList</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddTransactionConfirmationItem -->
	<xs:element name="AddTransactionConfirmationItemRequest" type="ns:AddTransactionConfirmationItemRequestType"/>
	<xs:complexType name="AddTransactionConfirmationItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Ends the listing specified by ItemID and creates a new Transaction
				Confirmation Request (TCR) for an item. A TCR enables a buyer
				to purchase an item. Applies to the US eBay Motors site (except
				Parts and Accessories category), effective in early July 2006.
				You can use this call for an item after the item has been
				listed for at least 24 hours. A TCR is sent by a seller to one
				of the following: a bidder, a best offer buyer, a member with
				an ASQ question, or any member with a postal code.
				Alternatively, this call can be used to verify that a new TCR
				can be created.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Ends the listing specified by ItemID and creates a new Transaction
						Confirmation Request (TCR) for an item.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="RecipientUserID" type="ns:UserIDType">
						<xs:annotation>
							<xs:documentation>
								Specifies the user to whom the seller is offering the Transaction Confirmation Request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="VerifyEligibilityOnly" type="xs:string">
						<xs:annotation>
							<xs:documentation>
								If true, specifies that the seller is verifying whether a new Transaction Confirmation Request
								(TCR) can be created.
								Thus, if this value is passed as true, then no Transaction Confirmation Request is actually made. If VerifyEligibilityOnly
								is not passed, or is false, a Transaction Confirmation Request is actually made.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RecipientPostalCode" type="xs:string">
						<xs:annotation>
							<xs:documentation>
								Specifies the postal code of the user to whom the seller is offering the Transaction Confirmation Request.
								Required only if the user does not meet the other options listed in RecipientRelationCodeType.
								An error is returned if RecipientUserID and RecipientPostalCode do not match for more than 3 times
								for a seller per day.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RecipientRelationType" type="ns:RecipientRelationCodeType">
						<xs:annotation>
							<xs:documentation>
								Specifies the current relationship between the seller and the potential buyer.
								A seller can make a Transaction Confirmation Request (TCR) for an item
								to a potential buyer if the buyer meets one of several criteria.
								A TCR is sent by a seller to one of the following: a bidder, a best offer buyer,
								a member with an ASQ question, or any member with a postal code. See the values and annotations in RecipientRelationCodeType.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="NegotiatedPrice" type="ns:AmountType">
						<xs:annotation>
							<xs:documentation>
								The amount the offer recipient must pay to buy the item
								specified in the Transaction Confirmation Request (TCR).
								A negotiated amount between the buyer and the seller.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ListingDuration" type="ns:SecondChanceOfferDurationCodeType">
						<xs:annotation>
							<xs:documentation>
								Specifies the length of time the item in the Transaction Confirmation Request (TCR) will be
								available for purchase.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType">
						<xs:annotation>
							<xs:documentation>
							  The ItemID of the item that the seller wants to end in order to create a Transaction Confirmation Request (TCR).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Comments" type="xs:string">
						<xs:annotation>
							<xs:documentation>
								Comments the seller wants to send to the recipient (bidder, best offer buyer, member with an ASQ question, or
								member with a postal code).
     					</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: AddTransactionConfirmationItem -->
	<xs:element name="AddTransactionConfirmationItemResponse" type="ns:AddTransactionConfirmationItemResponseType"/>
	<xs:complexType name="AddTransactionConfirmationItemResponseType">
		<xs:annotation>
			<xs:documentation>
          Returns an item ID for a new Transaction Confirmation Request (TCR). 
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  The new item ID for the item in the new Transaction Confirmation Request (TCR). 
                  This field is not returned if the request was only used to verify that a new TCR could be created.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  The date and time when the item in the new Transaction Confirmation Request (TCR)
                  becomes available for purchase.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  The date and time when the item in the new Transaction Confirmation Request (TCR)
                  is no longer available for purchase.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddTransactionConfirmationItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ApproveLiveAuctionBidders -->
	<xs:element name="ApproveLiveAuctionBiddersRequest" type="ns:ApproveLiveAuctionBiddersRequestType"/>
	<xs:complexType name="ApproveLiveAuctionBiddersRequestType">
		<xs:annotation>
			<xs:documentation>
				Provides Live Auction sellers with the ability to approve, decline,
				and set the bidding limit of the bidders that have signed up for a catalog.
				Includes the list of bidders for the requested item as part of the
				general item listing data.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Provides Live Auction sellers with the ability to approve, decline,
						and set the bidding limit of the bidders that have signed up for a catalog.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="UserCatalogID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number that identifies the seller's eBay Live Auctions catalog for which
								they want to set bidding limits and approve or decline bidders.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ApproveLiveAuctionBidders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BidApproval" type="ns:BidApprovalArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Approval details for a specific set of bidders.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ApproveLiveAuctionBidders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ApproveAllPending" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								This will approve all bidders in the catalog in the pending status only.
								This is an optional field. If provided and set to true, do not send BidApproval.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ApproveLiveAuctionBidders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AllApprovedBiddingLimit" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								This is the amount that bidders are beings approved for.
								This is required if user has set ApproveAllPending to true.
								It only applies to bidder requests that are in pending status.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ApproveLiveAuctionBidders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ApproveLiveAuctionBidders -->
<!-- W3C Schema generated by XMLSPY v5 rel. 4 U (http://www.xmlspy.com)
  -->
	<xs:element name="ApproveLiveAuctionBiddersResponse" type="ns:ApproveLiveAuctionBiddersResponseType"/>
	<xs:complexType name="ApproveLiveAuctionBiddersResponseType">
		<xs:annotation>
			<xs:documentation>
			Provides the Live Auction sellers with the ability to approve, decline,
			and set the bidding limit of the bidders that have signed up for a catalog.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="BidderUpdateStatus" type="ns:LiveAuctionApprovalStatusArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains the results of the request for each item.
							Mulitple bidders can be approved with one call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ApproveLiveAuctionBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: CompleteSale -->
	<xs:element name="CompleteSaleRequest" type="ns:CompleteSaleRequestType"/>
	<xs:complexType name="CompleteSaleRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to do various tasks after processing a
				transaction.
				The seller can leave feedback for the buyer, change the paid
				status in My eBay, and/or change the shipped status in My eBay.
				Only the seller who listed the item can perform these tasks. This
				call can be executed at any time after a transaction has been
				created. However, it is a good idea to wait until the sale is
				complete before using this call.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to do the following tasks after processing a
						transaction: leave feedback for the buyer, change the paid status in My eBay, or change the shipped status in My eBay (or any combination of these). 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the listing associated with the transaction that the
								seller is completing.
								Required.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>CompleteSale</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique identifier for a transaction from the listing indicated by ItemID.
								Call GetItemTransactions or GetSellerTransactions to determine
								the appropriate transaction ID.
								Required for all listing types (pass 0 for Chinese auctions).
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>CompleteSale</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeedbackInfo" type="ns:FeedbackInfoType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies feedback the seller is leaving for the buyer.
								For a given transaction, the seller can leave feedback once,
								and no further modifications can be made to that feedback entry.
								If feedback has already been left, FeedbackInfo is not allowed.
								Call GetFeedback to determine whether feedback has already been left.
								Optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>CompleteSale</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Shipped" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, the transaction is marked as shipped in My eBay
								(applicable for Selling Manager Pro users).
								If false, the transaction is marked as not shipped in My eBay.
								If not specified, the shipped status in My eBay is not modified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>CompleteSale</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Paid" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, the transaction is marked as paid in My eBay.
								If false, the transaction is marked as not paid in My eBay.
								If not specified, the paid status in My eBay is not modified.
								Optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>CompleteSale</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: CompleteSale -->
	<xs:element name="CompleteSaleResponse" type="ns:CompleteSaleResponseType"/>
	<xs:complexType name="CompleteSaleResponseType">
		<xs:annotation>
			<xs:documentation>
      Indicates the success or failure of the attempt to leave feedback for the buyer, 
      change the paid status in My eBay, and/or change the shipped status in My eBay.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: DeleteMyMessages -->
	<xs:element name="DeleteMyMessagesRequest" type="ns:DeleteMyMessagesRequestType" />
	<xs:complexType name="DeleteMyMessagesRequestType">
		<xs:annotation>
			<xs:documentation>
				Removes selected alerts and messages for a given user. Alerts that
				require action and have not been resolved by the user cannot be
				deleted.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Removes selected alerts and messages for a given user.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AlertIDs" type="ns:MyMessagesAlertIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of up to 10 AlertID values.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>DeleteMyMessages</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MessageIDs" type="ns:MyMessagesMessageIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of up to 10 MessageID values.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>DeleteMyMessages</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: DeleteMyMessages -->
	<xs:element name="DeleteMyMessagesResponse" type="ns:DeleteMyMessagesResponseType"/>
	<xs:complexType name="DeleteMyMessagesResponseType">
		<xs:annotation>
			<xs:documentation>
				The response to DeleteMyMessagesRequestType. If the request was successful, 
				DeleteMyMessages returns nothing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: EndItem -->
	<xs:element name="EndItemRequest" type="ns:EndItemRequestType"/>
	<xs:complexType name="EndItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Ends the specified item listing. Used by a seller to end the
				listing before it would normally end, such as before the
				specified duration has passed or the item was purchased via
				a Buy It Now option. Only the item's seller may call EndItem
				to end the item listing. Applicable to items listed on eBay.com
				and Half.com.
				For eBay Live Auctions, you cannot delete items that have been closed or that
				are part of a Live Auction event that has started.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Ends the specified item listing before the date and time at which
						it would normally end (per the listing duration). For competitive-bidding listings
						that have bids on them, the listing ends as a successful auction with
						winning bidder(s) unless the seller first cancels the bids. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID that identifies the item listing to end.
								Also applicable to Half.com. For Half.com listings, you can either
								specify ItemID or SellerInventoryID.
								For eBay Live Auctions, you cannot delete items that have been closed
								or that are part of a Live Auction event that has started.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>EndItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndingReason" type="ns:EndReasonCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the seller's reason for ending the listing early.
								This field is required if the seller is ending the item early and the item
								did not successfully sell.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>EndItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerInventoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique identifier that the seller specified when they listed the
								Half.com item. For Half.com items, you can either specify ItemID or SellerInventoryID.
								If you specify both ItemID and SellerInventoryID, they must be for the same item
								(otherwise an error will occur).
								Only applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>EndItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: EndItem -->
	<xs:element name="EndItemResponse" type="ns:EndItemResponseType"/>
	<xs:complexType name="EndItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Includes the acknowledgement of date and time the auction was
				ended due to the call to EndItem.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the date and time (returned in GMT) the specified item listing
								was ended.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>EndItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: FetchToken -->
	<xs:element name="FetchTokenRequest" type="ns:FetchTokenRequestType"/>
	<xs:complexType name="FetchTokenRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves an authentication token for the user. Can be used to get
				the token only after the user gives consent for the token to be
				generated via the eBay signin page. This call must be
				authenticated using the username and password of the application,
				rather than a token. After retrieval, the token can be used to authenticate other calls. 
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves an authentication token for the user.
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Authentication &amp; Authorization</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="SecretID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A value that is associated with the token retrieval request. The secret ID
								is a value that is defined by the application, and is passed in redirect
								URL to the eBay signin page. eBay recommends using a UUID for the secret
								ID value. You must also set Username (part of the RequesterCredentials)
								for the particular user of interest.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>FetchToken</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: FetchToken -->
	<xs:element name="FetchTokenResponse" type="ns:FetchTokenResponseType"/>
	<xs:complexType name="FetchTokenResponseType">
		<xs:annotation>
			<xs:documentation>
				Includes the authentication token for the user and the date it expires.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="eBayAuthToken" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The authentication token for the user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>FetchToken</CallName>
									<Returned>Always</Returned>
								</CallInfo>
								<SeeLink>
									<Title>Authentication &amp; Authorization</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HardExpirationTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Date and time at which the token returned in eBayAuthToken expires
								and can no longer be used to authenticate the user for that application.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>FetchToken</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAccount -->
	<xs:element name="GetAccountRequest" type="ns:GetAccountRequestType"/>
	<xs:complexType name="GetAccountRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to retreive his or her own account data. Returns account
				entries, including credits and debits, in a report format the user selects.
				Also returns summary data for the account.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to retreive his or her own account data.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AccountHistorySelection" type="ns:AccountHistorySelectionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the report format in which to return account entries.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="InvoiceDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Specifies the month and year of the invoice requested. The report
							includes only the entries that appear on the seller's invoice in the specified month
							and year. An entry can occur in one month and appear on the next month's
							invoice. Used with SpecifiedInvoice reports.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BeginDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Specifies the beginning of a date range during which a credit or debit
							occurred. Used when AccountHistorySelection is BetweenSpecifiedDates.
							Value must be less than or equal to the value specified in EndDate. The allowed date
							formats are YYYY-MM-DD and YYYY-MM-DD HH:mm:ss.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Specifies the end of a date range during which a credit or debit
							occurred. Used when AccountHistorySelection is BetweenSpecifiedDates.
							Value must be greater than or equal to the value specified in BeginDate. The
							allowed date formats are YYYY-MM-DD and YYYY-MM-DD HH:mm:ss.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Controls pagination of the response. For this request, the valid values
							of Pagination.EntriesPerPage are 0 to 2000, with a default of 500.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExcludeBalance" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
					          Specifies whether to calculate balances. Default is
							  false, which calculates balances. The value true means
							  do not calculate balances. If true, AccountEntry.Balance and
							  AccountSummary.CurrentBalance are never returned in the response.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExcludeSummary" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether to return account summary information in an
								AccountSummary node. Default is true, to return AccountSummary.
						  </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AccountEntrySortType" type="ns:AccountEntrySortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how account entries should be sorted in
								the response, by an element and then in ascending or
								descending order.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
						  	Specifies the currency used in the account report. Do not specify Currency in the request
						  	unless the following conditions are met. First, the user has or had multiple accounts under
						  	the same UserID. Second, the account identified in the request uses the currency you specify in the request. An error is returned if no account is found that uses the currency you specify in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAccount -->
	<xs:element name="GetAccountResponse" type="ns:GetAccountResponseType"/>
	<xs:complexType name="GetAccountResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns information about an eBay seller's own account.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="AccountID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the seller's unique account number. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AccountSummary" type="ns:AccountSummaryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains summary data for the seller's account, such as the overall
								balance, bank account and credit card information, and amount and
								date of any past due balances. Can also contain data for
								one or more additional accounts, if the user has changed country
								of residence.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the currency used for monetary amounts in the report.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AccountEntries" type="ns:AccountEntriesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains individual account entries, according to the report's scope and date range.
							Each account entry represents one credit, debit, or administrative account action.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the total number of pages (TotalNumberOfPages) and the total
								number of account entries (TotalNumberOfEntries) that can be returned
								on repeated calls with the same format and report criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreEntries" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether there are more items yet to be retrieved. Additional calls 
								must be made to retrieve those items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EntriesPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Specifies the number of items that are being returned per virtual page of date.
							Value is the same as that specified in Pagination.EntriesPerPage.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Indicates which page of data was just returned. Value is the same as the value
							specified in Pagination.PageNumber. If PageNumber in the request is higher than
							the total number of pages, the call fails with an error.)
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAccount</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAdFormatLeads -->
	<xs:element name="GetAdFormatLeadsRequest" type="ns:GetAdFormatLeadsRequestType"/>
	<xs:complexType name="GetAdFormatLeadsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieve sales lead information for a real estate
				advertisement listing. GetAdFormatLeadsRequest returns
				the number of leads for an ad and any contact
				information that the buyer submitted.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieve sales lead information for a real estate
						advertisement listing.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier of an item listed on the eBay site.
								Returned by eBay when the item is created. This ID must correspond to an ad format item.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
							  <CallInfo>
  								<CallName>GetAdFormatLeads</CallName>
  								<RequiredInput>Yes</RequiredInput>
  							</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAdFormatLeads -->
	<xs:element name="GetAdFormatLeadsResponse" type="ns:GetAdFormatLeadsResponseType"/>
	<xs:complexType name="GetAdFormatLeadsResponseType">
		<xs:annotation>
			<xs:documentation>
				(out) Returns number of leads and contact and other information for each lead. One AdFormatLead node is returned for each lead.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="AdFormatLead" type="ns:AdFormatLeadType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
							(out) Contains contact and other information for one lead. One node is returned for each lead. Only returned at a detail level of ReturnAll. At least one lead must be available for the specified item to return AdFormatLead.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAdFormatLeads</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AdFormatLeadCount" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							(out) The total number of leads returned. Only returned if you do not specify a detail level.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAdFormatLeads</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAllBidders -->
	<xs:element name="GetAllBiddersRequest" type="ns:GetAllBiddersRequestType"/>
	<xs:complexType name="GetAllBiddersRequestType">
		<xs:annotation>
			<xs:documentation>
				Includes the list of bidders for the requested item as part of the general item listing data.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Provides three modes for retrieving a list of the users that bid
						on a listing. One of the modes is of particular value in support of
						the Second Chance Offer feature. Includes the list of bidders for the
						requested item as part of the general item listing data.
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Extending a Second Chance Offer</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExtendingSecondChanceOffer</URL>
					<For>detailed information on working with the result set</For>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The item ID for which to retrieve the list of bidders.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetAllBidders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CallMode" type="ns:GetAllBiddersModeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies which bidder information to return.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAllBidders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAllBidders -->
	<xs:element name="GetAllBiddersResponse" type="ns:GetAllBiddersResponseType"/>
	<xs:complexType name="GetAllBiddersResponseType">
		<xs:annotation>
			<xs:documentation>
				Includes the list of bidders for the requested item as part of the general item listing data.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="BidArray" type="ns:OfferArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of OfferType objects. Each
								OfferType object represents the data for one bidder and bid.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAllBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HighBidder" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								eBay user ID for the user with the highest bid (or the earliest timestamp, in the
								event of a tie); a second chance off candidate.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAllBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HighestBid" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Bid amount offered by the HighBidder.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAllBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ListingStatus" type="ns:ListingStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies an active or ended listing's status in eBay's processing workflow.
								If a listing ends with a sale (or sales), eBay needs to update the sale details
								(e.g., winning bidder) and other information. This processing
								can take several minutes. If you retrieve a sold item, use this listing status information
								to determine whether eBay has finished processing the listing so that you can
								be sure the winning bidder and other details are correct and complete.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAllBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetApiAccessRules -->
	<xs:element name="GetApiAccessRulesRequest" type="ns:GetApiAccessRulesRequestType"/>
	<xs:complexType name="GetApiAccessRulesRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests the rules for accessing eBay API calls and your
				application's daily, hourly, and periodic usage of each call.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests the rules for accessing eBay API calls and your
						application's daily, hourly, and periodic usage of each call.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetApiAccessRules -->
	<xs:element name="GetApiAccessRulesResponse" type="ns:GetApiAccessRulesResponseType"/>
	<xs:complexType name="GetApiAccessRulesResponseType">
		<xs:annotation>
			<xs:documentation>
Returns a list of API access rules, in response
to a GetApiAccessRulesRequest.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ApiAccessRule" type="ns:ApiAccessRuleType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Contains the description of an API access rule, including the
								call name, the application's current daily and hourly usage,
								and other values.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetApiAccessRules</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAttributesCS -->
	<xs:element name="GetAttributesCSRequest" type="ns:GetAttributesCSRequestType"/>
	<xs:complexType name="GetAttributesCSRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves an XML string that describes how to present Item
				Specifics to a seller. Use this information to present users with
				the equivalent of the Item Specifics portion of the eBay Title
				and Description pages and to validate selected eBay attributes on
				the client before including them in an AddItem call or related
				calls. The XML string contains a list of all the attributes that
				are applicable for one or more requested categories, along with
				related meta-data. The meta-data specifies all the possible
				values of each attribute, the logic for presenting the attributes
				to a user, and rules for validating the user's selections. See
				the Developer's Guide for an overview of Item Specifics and
				details about the eBay attribute model.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves an XML string that describes how to present Item
						Specifics to a seller. Item Specifics are optional when listing in most categories;
						however, some categories (such as Real Estate, US Tickets, and US eBay Motors)
						require Item Specifics to be specified.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A version of the Item Specifics meta-data definitions for the site.
								Typically, an application passes the version value that was returned the last
								time the application executed this call.
								Filter that causes the call to return only the characteristics sets
								for which the attribute meta-data has changed since the specified version.
								If not specified, all characteristics sets are returned.
								The latest version value is not necessarily greater than the previous
								value that was returned. Therefore, when comparing versions, only
								compare whether the value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesCS</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AttributeSetID" type="xs:int" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								An array of characteristic setIDs (which always correspond to attribute set IDs).
								Each characteristic setcorresponds to a level in the eBay category hierarchy at
								which all items share common characteristics.
								Multiple categories can be mapped to the same characteristics set.
								AttributeSetIDs is an optional input. When IDs are specified, the call
								only returns meta-data for the corresponding characteristics sets.
								When no IDs are specified, the call returns all the current meta-data in the system.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesCS</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeCategoryMappingDetails" type="xs:boolean" default="false" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, includes a list of CategoryMapping nodes in the response.
								Each CategoryMapping node specifies category information as well as
								attributes and values that your application can auto-fill for
								items listed in that category. See the eBay Web Services Guide for more
								information about options for maintaining category data and
								auto-filling Item Specifics.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesCS</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DigitalDelivery" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, the characteristic set data is customized for digitally delivered items.
								In the digital delivery variation of the response, there are no changes to the attribute set IDs,
								attribute IDs, or value IDs, but "return policy" text is replaced with "refund policy" text
								and the Item Condition attribute is removed from all applicable characteristic sets.
								If a seller specifies that they are listing a digital item,
								you can render this variation of the applicable meta-data in your Item Specifics or Return Policy form.
								(You can use the Item Specifics SYI XSL stylesheet to render the data as usual.)
								Usage of this information is optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesCS</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAttributesCS -->
	<xs:element name="GetAttributesCSResponse" type="ns:GetAttributesCSResponseType"/>
	<xs:complexType name="GetAttributesCSResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns XML that describes how to present Item Specifics to a seller
				and how to validate selected eBay attributes on the client before including
				them in an AddItem call or related calls.
				See the Developer's Guide for an overview of Item Specifics and details about
				the eBay attribute model. Also returns the current version of the meta-data system.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Current version of the Item Specifics meta-data system for the site.
								This value changes each time changes are made to the meta-data.
								The current version value is not necessarily greater than the previous
								value. Therefore, when comparing versions, only compare whether the
								value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesCS</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AttributeData" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A string containing a list of all the attributes that are applicable
								to the site (or characteristic sets in the request), along with related meta-data.
								The meta-data specifies all the possible values of each attribute, the
								logic for presenting attributes to a user, and rules for validating the
								user's selections. This data is in the same XML format that was used in the
								Legacy XML API so that you can apply the same Item Specifics XSL stylesheet and
								your own patching stylesheets to it. That is, individual
								elements are not described using the new eBay XML schema format.
								For information about each element in the AttributeData string,
								see the attribute model documentation in the eBay Web Services guide (see links below).&lt;br&gt;
								&lt;br&gt;
								Because this is returned as a string, the XML markup elements are escaped with
								character entity references (e.g.,&amp;amp;lt;eBay&amp;amp;gt;&amp;amp;lt;Attributes&amp;amp;gt;...).
								See the appendices in the eBay Web Services guide for general information about
								string data types.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesCS</CallName>
									<Returned>Always</Returned>
								</CallInfo>
								<SeeLink>
									<Title>The Attribute Meta-Data Model</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AttrModel</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAttributesXSL -->
	<xs:element name="GetAttributesXSLRequest" type="ns:GetAttributesXSLRequestType"/>
	<xs:complexType name="GetAttributesXSLRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the Item Specifics SYI XSL stylesheet. Apply the stylesheet to the
				XML returned from a call to GetAttributesCS or GetProductSellingPages to
				render a form like the Item Specifics portion of eBay's Title and Description page.
				See the eBay Web Services Guide for an overview of Item Specifics and information
				on working with the XSL.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the Item Specifics SYI XSL stylesheet for use with
						the GetAttributesCS and GetProductSellingPages response.
						You use the stylesheet to render Item Specifics in a user interface,
						as applicable within a particular category.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="FileName" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The name of the XSL file to retrieve. If not specified, the call
								returns the latest versions of all available XSL files.
								FileName is an optional input. Valid values&lt;br&gt;
								&lt;br&gt;
                  syi_attributes.xsl
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesXSL</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FileVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The desired version of the XSL file. Required if FileName is specified.
								If not specified, the call returns the latest version of the file.
								(This is not a filter for retrieving changes to the XSL file.)
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesXSL</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetAttributesXSL -->
	<xs:element name="GetAttributesXSLResponse" type="ns:GetAttributesXSLResponseType"/>
	<xs:complexType name="GetAttributesXSLResponseType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the Item Specifics SYI XSL stylesheet.Apply the stylesheet to the
				XML returned from a call to GetAttributesCS or GetProductSellingPages to
				render a form like the Item Specifics portion of eBay's Title and Description page.
				See the Developer's Guide for an overview of Item Specifics and information
				on working with the XSL.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="XSLFile" type="ns:XSLFileType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Child elements contain data related to one XSL file.
 								Multiple XSLFile objects can be returned. However, currently only
 								one is returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetAttributesXSL</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetBestOffers -->
	<xs:element name="GetBestOffersRequest" type="ns:GetBestOffersRequestType"/>
	<xs:complexType name="GetBestOffersRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the best offers associated with ItemID according to the
				BestOfferStatus filter, where Active is the default.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the best offers associated with ItemID according to the
						BestOfferStatus filter, where Active is the default.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The item for which Best Offer information is to be returned.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetBestOffers</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BestOfferID" type="ns:BestOfferIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The specific Best Offer for which details are to be
								retrieved. Omit this tag to get a list of all best offers
								(according to BestOfferStatus).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBestOffers</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BestOfferStatus" type="ns:BestOfferStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A filter determining which Best Offers to return for an item. Active is the default.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBestOffers</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetBestOffers -->
	<xs:element name="GetBestOffersResponse" type="ns:GetBestOffersResponseType"/>
	<xs:complexType name="GetBestOffersResponseType">
		<xs:annotation>
			<xs:documentation>
				All best offers for the item according to the filter or best offer 
				id (or both) used in the input.
				For the notification client usage, this response includes a 
				single Best Offer.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="BestOfferArray" type="ns:BestOfferArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								All best offers for the item according to the filter or 
								best offer id (or both) used in the input. The buyer and 
								seller messages are returned only if the detail level is 
								defined. Includes the buyer and seller message only if 
								detail level ReturnAll is used.
								Only returned if best offers have been made.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBestOffers</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The item for which Best Offers are being returned.
								Only returned if best offers have been made.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBestOffers</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetBidderList -->
	<xs:element name="GetBidderListRequest" type="ns:GetBidderListRequestType"/>
	<xs:complexType name="GetBidderListRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves all items on which the user is currently bidding or
				which the buyer has won or purchased.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves all items on which the user is currently bidding or
						which the buyer has won or purchased.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:annotation>
				<xs:documentation>
					Retrieves all items on which the user is currently bidding or
					which the buyer has won or purchased.
				</xs:documentation>
			</xs:annotation>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ActiveItemsOnly" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether to limit the result set to active items.
								If true, only active items are returned and the EndTimeFrom
								and EndTimeTo filters are ignored. If false (or not sent),
								active and ended items are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits returned items to only those for which the item's
								end date is on or after the date-time specified. Specify an
								end date within 30 days prior to today. Items that ended
								more than 30 days ago are omitted from the results. If
								specified, EndTimeTo must also be specified. Express
								date-time in the format YYYY-MM-DD HH:MM:SS, and in GMT.
								(For information on how to convert between your local time zone
								and GMT, see Time Values Note.) This field is ignored if ActiveItemsOnly is true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits returned items to only those for which the item's
								end date is on or before the date-time specified. If
								specified, EndTimeFrom must also be specified. Express
								date-time in the format YYYY-MM-DD HH:MM:SS, and in GMT.
								This field is ignored if ActiveItemsOnly is true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The user for whom information should be returned. If
								provided, overrides user defined via RequesterCredentials
								in header.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="GranularityLevel" type="ns:GranularityLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								For GetBidderList, you can reduce the ItemType fields and other fields returned
								by specifying one of two values in the GranularityLevel field, Coarse or Medium.
								If you specify Coarse, the primary fields returned are the following: Item.ItemID and Item.ListingDetails.EndTime. If you specify Medium, an abbreviated result set is returned
								that includes many more fields than in the case of Coarse, including the following:
								Item.BuyItNowPrice, Item.Currency, Item.Site, and Item.Title.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetBidderList -->
	<xs:element name="GetBidderListResponse" type="ns:GetBidderListResponseType"/>
	<xs:complexType name="GetBidderListResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to GetBidderListRequest.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:annotation>
				<xs:documentation>
					Response to GetBidderListRequest.
				</xs:documentation>
			</xs:annotation>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Bidder" type="ns:UserType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Data for one eBay bidder.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BidItemArray" type="ns:ItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Array of items the bidder has bid on, has won or has lost.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetBidderList</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategories -->
	<xs:element name="GetCategoriesRequest" type="ns:GetCategoriesRequestType"/>
	<xs:complexType name="GetCategoriesRequestType">
		<xs:annotation>
			<xs:documentation>
				Contains the inputs that determine which categories to return and from
				which eBay site to get them. Retrieves the category hierarchy including
				and under the category (or categories) specified in CategoryParent.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves from eBay the latest category hierarchy.
						Information returned for each category includes the category name
						and the unique identifier for the category
						(unique within the eBay site for which categories are retrieved).
						A category ID is a required input for most new items.
					</Summary>
					<TempInfo>dl</TempInfo>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategorySiteID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the eBay site for which to retrieve the category hierarchy.
								Use the numeric site code (e.g., 77 for eBay Germany).
								Only necessary if you want to retrieve category data
								for a site other than the site to which you are submitting the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<RequiredInput>No</RequiredInput>
									<Default>The site ID of the request</Default>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryParent" type="xs:string" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Specifies the ID of the highest-level category to return, along with its subcategories.
								If no parent category is specified, all categories are returned for the specified site.
								To determine available category IDs, call GetCategories with no filters and use a DetailLevel value of ReturnAll.
								If you specify multiple parent categories, the hierarchy for each one is returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<RequiredInput>No</RequiredInput>
									<Default>0</Default>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LevelLimit" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the maximum depth of the category hierarchy to retrieve, where the top-level categories
								(meta-categories) are at level 1. Retrieves all category nodes with
								a category level less than or equal to this value.
								If not specified, then categories at all applicable levels can be returned.
								As with all calls, the actual data returned will vary depending on how you configure
								other fields in the request (inicluding the DetailLevel).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<RequiredInput>No</RequiredInput>
									<Default>0</Default>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ViewAllNodes" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If false or omitted, only leaf categories are returned.
								(You can only list in leaf categories.)
								If true, both leaf and internal (non-leaf) categories are returned.
								As with all calls, the actual data returned will vary depending on how you configure
								other fields in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<RequiredInput>No</RequiredInput>
									<Default>false</Default>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategories -->
	<xs:element name="GetCategoriesResponse" type="ns:GetCategoriesResponseType"/>
	<xs:complexType name="GetCategoriesResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the category data for the eBay site specified as input. The category
				data is contained in a CategoryArrayType object, within which are zero, one, or
				multiple CategoryType objects. Each CategoryType object contains the detail data
				for one category. Other fields tell how many categories are returned in a call,
				when the category hierarchy was last updated, and the version of the category
				hierarchy (all three of which can differ from one eBay site to the next).
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CategoryArray" type="ns:CategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								List of the returned categories. The category array contains one CategoryType
								object for each returned category. Returns empty if no detail level is specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryCount" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the number of categories returned (i.e., the number of CategoryType
								objects in CategoryArray).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UpdateTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the last date and time that eBay modified the category hierarchy for the
								specified eBay site.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the version of the category hierarchy on the 
								specified eBay site.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReservePriceInclusive" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							The ReservePriceInclusive and ReduceReserveInclusive fields will be deprecated 
							in a future release. We recommend that you start using ReduceReserveAllowed and 
							ReservePriceAllowed instead of these "inclusive" fields as soon as possible.
							The names of ReservePriceInclusive and ReduceReserveInclusive are REVERSED.
							If true, ReservePriceInclusive indicates that all categories on the 
							site allow the seller to REDUCE an item's reserve price. 
							If false, all categories on the site do not normally allow sellers to reduce an 
							item's reserve price.
							The Category.ORRA (override reduce reserve price) field can override (or toggle)
							the reserve price reduction setting for a given category.
							For example, if ReservePriceInclusive is false and Category.ORRA is true,
							the category overrides the site setting and supports reducing reserve prices. 
							If ReservePriceInclusive is true and Category.ORRA is true, the category
							overrides the site setting and does does not support reducing reserve prices.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<TagStatus>Deprecated</TagStatus>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReservePriceAllowed" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							If true, ReservePriceAllowed indicates that all categories on the 
							site allow the seller to specify a reserve price for an item.
							If false, all categories on the site do not normally allow sellers to specify reserve prices.
							The Category.ORPA (override reserve price allowed) field can override (or toggle)
							the reserve price allowed setting for a given category.
							For example, if ReservePriceAllowed is false and Category.ORPA is true,
							the category overrides the site setting and supports reserve prices. 
							If ReservePriceAllowed is true and Category.ORPA is true, the category
							overrides the site setting and does does not support reserve prices.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MinimumReservePrice" type="xs:double" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
	    					Indicates the lowest possible reserve price allowed for any item
	    					listed in any category on the site. You can use the fields returned by GetCategoryFeatures to determine if a different Minimum Reserve Price is defined for the category you want to use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation> 
							Not used.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Conditionally</Returned>
									<TagStatus>Obsolete</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReduceReserveInclusive" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							The ReservePriceInclusive and ReduceReserveInclusive fields will be deprecated 
							in a future release. We recommend that you start using ReduceReserveAllowed and 
							ReservePriceAllowed instead of these "inclusive" fields as soon as possible.
							The names of ReservePriceInclusive and ReduceReserveInclusive are REVERSED.
							If true, ReduceReserveInclusive indicates that all categories on the 
							site allow the seller to SPECIFY a reserve price for an item.
							If false, all categories on the site do not normally allow sellers to specify reserve prices.
							The Category.ORPA (override reserve price allowed) field can override (or toggle)
							the reserve price inclusive setting for a given category.
							For example, if ReduceReserveInclusive is false and Category.ORPA is true,
							the category overrides the site setting and supports reserve prices. 
							If ReduceReserveInclusive is true and Category.ORPA is true, the category
							overrides the site setting and does does not support reserve prices.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<TagStatus>Deprecated</TagStatus>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReduceReserveAllowed" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							If true, ReduceReserveAllowed indicates that all categories on the 
							site allow the seller to reduce an item's reserve price. 
							If false, all categories on the site do not normally allow sellers to reduce an 
							item's reserve price.
							The Category.ORRA (override reduce reserve price) field can override (or toggle)
							the reserve price reduction setting for a given category.
							For example, if ReduceReserveAllowed is false and Category.ORRA is true,
							the category overrides the site setting and supports reducing reserve prices. 
							If ReduceReserveAllowed is true and Category.ORRA is true, the category
							overrides the site setting and does does not support reducing reserve prices.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategories</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategory2CS -->
	<xs:element name="GetCategory2CSRequest" type="ns:GetCategory2CSRequestType"/>
	<xs:complexType name="GetCategory2CSRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves mappings between categories and characteristics sets that are available for an eBay site.
				Retrieves all mappings or just those that match category IDs passed in the call.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves mappings between categories and characteristics
						sets that are available for an eBay site.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of a category for which to retrieve mappings. If not specified, the call
								retrieves a map for all categories.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetCategory2CS</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A version of the mappings for the site.
								Typically, an application passes the version value that was returned the last
								time the application executed this call.
								Filter that causes the call to return only the categories
								for which the mappings have changed since the specified version.
								If not specified, all category-to-characteristics set mappings are returned.
								This value changes each time changes are made to the mappings.
								The current version value is not necessarily greater than the previous
								value. Therefore, when comparing versions, only compare whether the
								value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2CS</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategory2CS -->
	<xs:element name="GetCategory2CSResponse" type="ns:GetCategory2CSResponseType"/>
	<xs:complexType name="GetCategory2CSResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns data that indicates the categories that are mapped to characteristics sets,
				for the eBay site to which the call was routed.
				Retrieves all mappings or just the one that matches the category ID passed as input.
				The data is returned in a CategoryArrayType object, which can contain multiple mappings.
				The response also contains information about categories for which the mappings have changed.&lt;br&gt;
				&lt;br&gt;
				&lt;span class="tablenote"&gt;&lt;b&gt;Note:&lt;/b&gt; The Pre-filled Item Information feature depends on the Item Specifics feature.
				This means the set of catalog-enabled categories is a subset of the categories
				that are mapped to characteristic sets. That is, there are no catalog-enabled categories
				that are not mapped to characteristic sets.&lt;/span&gt;
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="MappedCategoryArray" type="ns:CategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains data about categories that are mapped to characteristics sets.
								Use this data to determine:
								- The names and IDs of the characteristics sets
								- The availability of the Pre-filled Item Information feature for listings in that category
									(i.e., whether the category is catalog-enabled)
								- For catalog-enabled categories, the available product search methods
								- The current version information for the complete mapping
								- The version information for each characteristics set
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2CS</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UnmappedCategoryArray" type="ns:CategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains data about categories (if any) whose characteristics set mappings have changed
								since the version specified in the request. When a characteristics set mapping
								changes, the data appears in both the UnmappedCategoryArray object
								(to indicate that the change occurred) and the MappedCategoryArray object.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2CS</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Current version of the mappings for the site.
								This value changes each time changes are made to the mappings.
								The current version value is not necessarily greater than the previous
								value. Therefore, when comparing versions, only compare whether the
								value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2CS</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SiteWideCharacteristicSets" type="ns:SiteWideCharacteristicsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A list of one or more characteristics sets mapped to the category, if any. Use this
								information when working with Item Specifics (Attributes) and Pre-filled Item
								Information (Catalogs) functionality.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2CS</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategory2FinanceOffer -->
	<xs:element name="GetCategory2FinanceOfferRequest" type="ns:GetCategory2FinanceOfferRequestType"/>
	<xs:complexType name="GetCategory2FinanceOfferRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the promotional financing offers available in a specified category
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the promotional financing offers available in a specified category.
					</Summary>
					<TempInfo>dl</TempInfo>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Retrieve the promotional financing offers for this category.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetCategory2FinanceOffer</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LastModifiedDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Date from which to retrieve financing offers.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2FinanceOffer</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategory2FinanceOffer -->
	<xs:element name="GetCategory2FinanceOfferResponse" type="ns:GetCategory2FinanceOfferResponseType"/>
	<xs:complexType name="GetCategory2FinanceOfferResponseType">
		<xs:complexContent>
			<xs:annotation>
				<xs:documentation>
					Contains either the set of finance offers for a given category, or the number
					of finance offers for a given category.
				</xs:documentation>
			</xs:annotation>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Count" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number of finance offers that apply to the specified category.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2FinanceOffer</CallName>
									<DetailLevels>none, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryFinanceOfferArray" type="ns:CategoryFinanceOfferArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Set of finance offers that apply to the specified category.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategory2FinanceOffer</CallName>
									<DetailLevels>ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategoryFeatures -->
	<xs:element name="GetCategoryFeaturesRequest" type="ns:GetCategoryFeaturesRequestType"/>
	<xs:complexType name="GetCategoryFeaturesRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns the categories on the site that have the features you
				requested in FeatureDefinitions. The return set might have fewer
				categories than the site has defined, because only some
				categories implement those features.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns information about features that may only be applicable to
						certain categories on the site, such as particular listing durations,
						shipping term requirements, and Best Offer features.
					</Summary>
					<TempInfo>dl</TempInfo>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Defines the category for which you want information.
								If not specified, returns all categories for the site.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LevelLimit" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the levels of categories to return. By specifying a value in
								LevelLimit, you retrieve all category nodes with a CategoryLevel less
								than or equal to the LevelLimit value.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ViewAllNodes" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies, when false or not specified, that just leaf category nodes
								be returned. When true, all applicable category nodes are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<RequiredInput>No</RequiredInput>
									<Default>false</Default>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeatureID" type="ns:FeatureIDCodeType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Identifies the feature you want information about. If no value is
								specified, the value defaults to all feature IDs.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategoryFeatures -->
	<xs:element name="GetCategoryFeaturesResponse" type="ns:GetCategoryFeaturesResponseType"/>
	<xs:complexType name="GetCategoryFeaturesResponseType">
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CategoryVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Returns the categories on the site that have the features you requested in FeatureIds. 
								The return set might have fewer categories than the site has defined, because only 
								some categories implement those features.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UpdateTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Gives the time in GMT that the category hierarchy was last updated. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category" type="ns:CategoryFeatureType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation> 
								Lists the categories on the site that have the features you requested in FeatureID. 
								The return set might have fewer categories than the site has defined, because only
								some categories implement those features. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<DetailLevels>ReturnAll</DetailLevels>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SiteDefaults" type="ns:SiteDefaultsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Returns feature definitions defined for the entire site. Each feature has a node
								in this section.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<DetailLevels>ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeatureDefinitions" type="ns:FeatureDefinitionsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Returns definitions and values for the various features you requested. Each feature
								has a node within FeatureDefinitions.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryFeatures</CallName>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategoryListings -->
	<xs:element name="GetCategoryListingsRequest" type="ns:GetCategoryListingsRequestType"/>
	<xs:complexType name="GetCategoryListingsRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns items in a specified category.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns items in a specified category. A number of inputs are provided
						for filtering the item listings returned using such criteria as
						location, whether the item is listed in an ebay Store, the listing type, and including or excluding specified sellers. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="MotorsGermanySearchable" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Filters the response based on each item's eligibility to appear on the mobile.de site.
								If false, excludes eligible items from search results. If true, queries for
								eligible items only. If not specified, the search results are not affected.
								Only applicable for items listed on the eBay Germany site (site ID 77) in subcategories of
								mobile.de search-enabled categories.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the category for which to retrieve item listings.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AdFormat" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Reserved for future use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Numeric ID for a currency type. Limits the result set to just those items listed
								using a specified currency. Not applicable to US eBay Motors searches.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemTypeFilter" type="ns:ItemTypeFilterCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Filters items based on the ListingType set for the items. 
								If you search for Store Inventory items, you should use values in ItemTypeFilter
								instead of StoresFixedPrice.								
								If ItemTypeFilter is not specified (or if the AllItemTypes value of ItemTypeFilter is specified), all listing types can be returned unless another relevant filter is specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StoresFixedPrice" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Ignored if Store-related values in ItemTypeFilterCodeType are used as input filters.
								Using values in ItemTypeFilterCodeType is preferable to using StoresFixedPrice.
								StoresFixedPrice controls whether or not to use Store Inventory format as a filtering criterion.
								If true, the results only include Store Inventory listings (with no listings in other formats).
								If false, the results only include listings in other formats (with no Store Inventory listings).
								If not specified (the default), this filter is not applied at all, so all formats can be returned.
								If you do not sort the results, Store Inventory listings normally appear after
								all matching auction and basic fixed price listings
								(for eBay sites that default to sorting by items ending soonest).
								If you pass StoresFixedPrice in the same request with ItemTypeFilter,
								"AND" logic may be applied, and you might not get the desired results.
								For example, if you specify StoresFixedPrice=true and ItemTypeFilter=AuctionItemsOnly,
								the call will succeed but no listings will be returned (because no listings can use both
								auction and Store Inventory formats).
								This is why it is recommended that you use values in ItemTypeFilterCodeType instead of StoresFixedPrice.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
									<TagStatus>ObsoleteSoon</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchType" type="ns:CategoryListingsSearchCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether to limit the item listings to just those that are
								category featured or super featured or all items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderBy" type="ns:CategoryListingsOrderCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the order in which the item listings returned will be sorted.
								Store Inventory listings are usually returned after other listing types, regardless of the sort order.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Controls the pagination of the result set. Child elements specify the
								maximum number of item listings to return per call and which page of data
								to return.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchLocation" type="ns:SearchLocationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items that meet location criteria:
								listed in a specified eBay site, location where the seller has the item,
								location from which the user is searching, and/or items listed with a
								specified currency.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProximitySearch" type="ns:ProximitySearchType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items that meet proximity search criteria:
								postal code and max distance.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeGetItFastItems" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(in) When passed with a value of 1 (true), only Get It Fast listings are returned.
								Controls the set of listings to return (not the details to return for each listing).
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentMethod" type="ns:PaymentMethodSearchCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies items that accept a specific payment method or methods.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeCondition" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								For eBay Germany only. If true, each item in the result set can also include the item condition attribute
								(whether the item is new or used). The item's condition is returned in Item.AttributeSetArray.
								An item only includes condition attribute if the item's seller filled in
								the Item Condition in the Item Specifics section of the listing.
								(That is, the condition attribute is not returned if the seller only put the word
								"New" in the listing's title but did not specify the condition in the listing's Item Specifics.)
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeFeedback" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							If true, each item in the result set also includes information about the seller's feedback.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LocalSearchPostalCode" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Include local items in returning results near this postal code. This postal code is the basis for local search.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategoryListings -->
	<xs:element name="GetCategoryListingsResponse" type="ns:GetCategoryListingsResponseType"/>
	<xs:complexType name="GetCategoryListingsResponseType">
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemArray" type="ns:ItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Contains the item listings for the specified category and which meet the
                  input filtering criteria (if any is specified). Consists of one ItemType
                  object for each returned item listing.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category" type="ns:CategoryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Indicates the category from which the listings were drawn.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SubCategories" type="ns:CategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Collection of the sub-categories that are child to the category indicated
                  in Category. Data for each sub-category is conveyed in a CategoryType
                  object.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Indicates the maximum number of item listings that will be returned per
                  call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Indicates the page of data returned in the current call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreItems" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
                  Indicates whether there are more item listings that can be returned
                  (items listed in the specified category and that meet any input filtering
                  criteria).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Indicates the results of the pagination, including the total number of
                  pages of data there are to be returned and the total number of items
                  there are to be returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BuyingGuideDetails" type="ns:BuyingGuideDetailsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Contains information about relevant buying guides (if any) and the site's buying guide hub.
                  Buying guides are useful to buyers who do not have a specific product in mind. 
                  For example, a digital camera buying guide could help a buyer determine what kind of 
                  digital camera is right for them.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryListings</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategoryMappings -->
	<xs:element name="GetCategoryMappingsRequest" type="ns:GetCategoryMappingsRequestType"/>
	<xs:complexType name="GetCategoryMappingsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a map of old category IDs and corresponding active
				category IDs defined for the site to which the request is sent.
				Typically used to update an older item definition with a new
				category ID prior to listing the item.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves a map of old category IDs and corresponding active
						category IDs defined for the site to which the request is sent.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								 A version of the category mapping for the site. Filters
								 out data from the call to return only the category
								 mappings for which the data has changed since the
								 specified version. If not specified, all category
								 mappings are returned. Typically, an application passes
								 the version value of the last set of category mappings
								 that the application stored locally. The latest version
								 value is not necessarily greater than the previous value
								 that was returned. Therefore, when comparing versions,
								 only compare whether the value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryMappings</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCategoryMappings -->
	<xs:element name="GetCategoryMappingsResponse" type="ns:GetCategoryMappingsResponseType"/>
	<xs:complexType name="GetCategoryMappingsResponseType">
		<xs:annotation>
			<xs:documentation>
Returns a map of old category IDs and corresponding active category IDs defined for 
the site to which the request was sent.
Typically used to update an older item definition with a new category ID 
prior to listing the item.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CategoryMapping" type="ns:CategoryMappingType" minOccurs="0" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation>
               Mapping between an old category ID and an active category ID. 
               Returned when category mappings exist and the value of CategoryVersion is 
               different from the current version on the site.
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetCategoryMappings</CallName>
								<Returned>Conditionally</Returned>
								<DetailLevels>ReturnAll</DetailLevels>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
					</xs:element>
					<xs:element name="CategoryVersion" type="xs:string" minOccurs="0" maxOccurs="1">
						<xs:annotation>
							<xs:documentation>
                  Version value assigned to the current category mapping data for the site. 
                  Compare this value to the version value the application stored with the mappings 
                  the last time the application executed the call. If the versions are the same, 
                  the data has not changed since the last time the data was retrieved and stored.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCategoryMappings</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCharities -->
	<xs:element name="GetCharitiesRequest" type="ns:GetCharitiesRequestType"/>
	<xs:complexType name="GetCharitiesRequestType">
		<xs:annotation>
			<xs:documentation>
				Searches for nonprofit charity organizations that meet the criteria specified in the request.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Searches for nonprofit charity organizations that meet the criteria specified in the request.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CharityID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A unique identification number assigned by eBay to registered nonprofit charity organizations.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CharityName" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A name assigned to a specified nonprofit
								organization. Accepts full charity nonprofit name
								or partial name as input. For example, enter a
								CharityName of "heart" (case-insensitive) to
								return all charity nonprofits that start with
								"heart." Use with a MatchType value of "Contains"
								to return all charity nonprofits that contain the
								string "heart."
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>150</MaxLength>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Query" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Accepts a case-insensitive string used to
								find a nonprofit charity organization. Default
								behavior is to search the CharityName field. Use
								with an IncludeDescription value of true to
								include the Mission field in the search.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>350 (characters)</MaxLength>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CharityRegion" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Region that the nonprofit charity organization is associated
								with. A specific nonprofit charity organization may be associated
								with only one region. Meaning of input values differs depending on
								the site. See GetCharities in the API Developer's Guide for the meaning
								of each input/output value. CharityRegion input value must be
								valid for that SiteID.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CharityDomain" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Domain (mission area) that a nonprofit charity organization
								belongs to. Nonprofit charity organizations may belong to multiple
								mission areas. Meaning of input values differs depending on the
								site. See GetCharities in the API Developer's Guide for the meaning
								of each input/output value. CharityDomain input value must be valid for
								that SiteID.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeDescription" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Used with Query to search for charity nonprofit
								organizations. A value of true will search the Mission field as
								well as the CharityName field for a string specified in Query.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MatchType" type="ns:StringMatchCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the type of string matching to use
								when a value is submitted in CharityName. If no
								value is specified, default behavior is
								"StartsWith." Does not apply to Query.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCharities</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCharities -->
	<xs:element name="GetCharitiesResponse" type="ns:GetCharitiesResponseType"/>
	<xs:complexType name="GetCharitiesResponseType">
		<xs:annotation>
			<xs:documentation>
			Contains information about charity nonprofit organizations that meet the 
			criteria specified in the request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Charity" type="ns:CharityInfoType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
							Contains information about charity nonprofit organizations that 
							meet the criteria specified in the request. One Charity node is 
							returned for each applicable nonprofit charity organization. The 
							CharityID value is returned as an id attribute of this node. If no 
							nonprofit charity organization is applicable, this node is not 
							returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
								<CallName>GetCharities</CallName>
								<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetContextualKeywords -->
	<xs:element name="GetContextualKeywordsRequest" type="ns:GetContextualKeywordsRequestType"/>
	<xs:complexType name="GetContextualKeywordsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves top-ranked contextual eBay keywords and categories
				for a specified web page. Results are ranked according
				to score. This enables developers to create applications that are different from
				traditional contextual ad serving. For instance, instead of building a standard
				ad banner or skyscraper ad like those from eBay AdContext, a developer could
				create an application that does inline hyperlinking of keywords on any page or
				create widgets for blog platforms.
				Not available for CN, TW, SG and HK sites.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves top-ranked contextual eBay keywords and categories
						for a specified web page.
					</Summary>
				</Overview>
				<SiteInfo>
					<ExcludeFromDefaultSites>CN, TW, SG, HK</ExcludeFromDefaultSites>
				</SiteInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="URL" type="xs:anyURI" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The URL of the web page from which eBay is to extract keywords.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetContextualKeywords</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Encoding" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Web page encoding by which the URL is to be handled, such as ISO-8859-1.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetContextualKeywords</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The ID of the category to which keywords are to be limited.
								Zero or more category IDs can be specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetContextualKeywords</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetContextualKeywords -->
	<xs:element name="GetContextualKeywordsResponse" type="ns:GetContextualKeywordsResponseType"/>
	<xs:complexType name="GetContextualKeywordsResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to a GetContextualKeywords request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ContextSearchAsset" type="ns:ContextSearchAssetType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								An array of either keyword/category pairs or categories, with ranking and score.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetContextualKeywords</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCrossPromotions -->
	<xs:element name="GetCrossPromotionsRequest" type="ns:GetCrossPromotionsRequestType"/>
	<xs:complexType name="GetCrossPromotionsRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests a list of cross-promoted items associated with a
				referring item.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests a list of cross-promoted items associated with a
						referring item.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique ID of the referring item. The cross-promoted
								items will supplement this item.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetCrossPromotions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PromotionMethod" type="ns:PromotionMethodCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The cross-promotion method you want to use for the
								returned list, either UpSell or CrossSell.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCrossPromotions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PromotionViewMode" type="ns:TradingRoleCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The role of the person requesting to view the cross-promoted
								items, either seller or buyer. Default is buyer.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCrossPromotions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetCrossPromotions -->
	<xs:element name="GetCrossPromotionsResponse" type="ns:GetCrossPromotionsResponseType"/>
	<xs:complexType name="GetCrossPromotionsResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns a list of either upsell or cross-sell items for a given item ID.
				The list can be filtered by the viewer's role, either buyer or seller. 
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CrossPromotion" type="ns:CrossPromotionsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation> 
							  A list of cross-promoted items defined for a specific
							  referring item. The list is either upsell or cross-sell
							  items, according to the value of PromotionMethod in 
							  GetCrossPromotionsRequest.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetCrossPromotions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetDescriptionTemplates -->
	<xs:element name="GetDescriptionTemplatesRequest" type="ns:GetDescriptionTemplatesRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the DescriptionTemplates for a category.
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GetDescriptionTemplatesRequestType">
		<xs:annotation>
			<xs:documentation>
				Request for DescriptionTemplates.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the DescriptionTemplates for a category.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The category for which to retrieve templates. Enter any
								category ID, including Motors vehicle categories. This
								is ignored if you also send MotorVehicles.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LastModifiedTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If specified, only those templates modified on or after the
								specified date are returned. If not specified, all templates are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MotorVehicles" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether to retrieve templates for motor vehicle
								categories for eBay Motors (site 100). If true, templates
								are returned for motor vehicle categories. If false,
								templates are returned for non-motor vehicle categories
								such as Parts and Accessories. If included as an input field (whether true or false), this overrides any value provided for CategoryID.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetDescriptionTemplates -->
	<xs:element name="GetDescriptionTemplatesResponse" type="ns:GetDescriptionTemplatesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns one or more DescriptionTemplate nodes. Each DescriptionTemplate node contains the information for one Theme or one Layout. DescriptionTemplate.DescriptionTemplateType indicates whether it contains data for a Theme or a Layout.
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GetDescriptionTemplatesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returned after calling GetDescriptionTemplatesRequest.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="DescriptionTemplate" type="ns:DescriptionTemplateType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The information for one Theme or one Layout. There 
								can be multiple DescriptionTemplates.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LayoutTotal" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The number of Layout templates returned (that is, the 
								number of DescriptionTemplates for which Type is "Layout").
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ObsoleteLayoutID" type="xs:int" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The ID of a returned layout that is obsolete. There can be zero or more IDs.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ObsoleteThemeID" type="xs:int" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The ID of a returned theme that is obsolete. There can be zero or more IDs.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ThemeGroup" type="ns:ThemeGroupType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Data for one theme group. There can be multiple 
								ThemeGroups in the response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ThemeTotal" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The number of Theme templates returned (that is, the number 
								of DescriptionTemplates for which Type is "Theme").					
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDescriptionTemplates</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetDispute -->
	<xs:element name="GetDisputeRequest" type="ns:GetDisputeRequestType"/>
	<xs:complexType name="GetDisputeRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests the record of a dispute with a given dispute ID.
				The dispute record contains the dispute state, dispute type, and other
				information. Can be used with Unpaid Item or Item Not Received disputes.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests the record of a dispute with a given dispute ID. Returns the entire record of a dispute,
						any time after the dispute was opened and up to five years after it was closed.
						Returns just one dispute, including any comments
						and resolutions and the dispute state. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="DisputeID" type="ns:DisputeIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier of the dispute, returned when the dispute is created.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetDispute -->
	<xs:element name="GetDisputeResponse" type="ns:GetDisputeResponseType"/>
	<xs:complexType name="GetDisputeResponseType">
		<xs:annotation>
			<xs:documentation>
        Returned after calling GetDisputeRequest. Returns the record of
      	a dispute, including the dispute state and other information.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Dispute" type="ns:DisputeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The dispute record, containing information about
								the buyer, seller, dispute state, dispute status,
								comments added to the dispute, or resolutions.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetDispute</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetFeedback -->
	<xs:element name="GetFeedbackRequest" type="ns:GetFeedbackRequestType"/>
	<xs:complexType name="GetFeedbackRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the accumulation of feedback left for the specified user by
				other users. Returns summary feedback data and (in a detail level value
				of ReturnAll is specified) individual feedbacks.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the accumulation of feedback left for the specified user
						by other users.
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Controls the pagination of the result set. Child elements specify the
								maximum number of individual feedbacks to return per call and which page
								of data to return. Only applicable if a detail level value of ReturnAll
								is specified to return feedback details. feedback summary data is not
								paginated (but is still returned when pagination is used).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the user whose feedback data is to be returned. If not specified,
								then the feedback returned is that for the requesting user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeedbackID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An ID that uniquely identifies a feedback to be retrieved.
								Used by the Feedback notification only.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetFeedback -->
	<xs:element name="GetFeedbackResponse" type="ns:GetFeedbackResponseType"/>
	<xs:complexType name="GetFeedbackResponseType">
		<xs:annotation>
			<xs:documentation>
				The GetFeedback response contains the specified user's total
				feedback score, feedback summary data, and (if the applicable
				detail level is specified) an array of individual feedbacks.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="FeedbackDetailArray" type="ns:FeedbackDetailArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Contains the individual feedbacks for the user, one FeedbackDetailType
								object for each feedback. Only populated with data when a detail level of
								ReturnAll is specified in the request. Not returned if you specify FeedbackID in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeedbackDetailItemTotal" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Indicates the number of FeedbackDetailType objects returned in the
								FeedbackDetailArray property. Only applicable if feedback details are
								returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeedbackSummary" type="ns:FeedbackSummaryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Summary feedback data for the user. Contains counts of positive, neutral,
								and negative feedback for predefined time periods. Only applicable if feedback details are
								returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FeedbackScore" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Indicates the total feedback score for the user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFeedback</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetFinanceOffers -->
	<xs:element name="GetFinanceOffersRequest" type="ns:GetFinanceOffersRequestType"/>
	<xs:complexType name="GetFinanceOffersRequestType">
		<xs:annotation>
				<xs:documentation>
					Retrieves either the current set of finance offers or a specific
					finance offer. Only supported on US and Canada sites. Payment method must be PayPal.
				</xs:documentation>
				<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves either the current set of finance offers or a specific
						finance offer. Only supported on US and Canada sites. Payment method must be PayPal.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="FinanceOfferID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
          			ID for promotional financing offer with which the seller is listing an item. If this is specified, the function returns only the finance offer associated with this ID number. If FinanceOfferID and LastModifiedDate are both used as input, LastModifiedDate is ignored.
            	</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFinanceOffers</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LastModifiedDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
          			Date from which to search for finance offers. If this is specified but
          			FinanceOfferID is not, this call will return those finance offers that
          			have been changed since this date.
            	</xs:documentation>
 							<xs:appinfo>
								<CallInfo>
	 								<CallName>GetFinanceOffers</CallName>
	 								<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetFinanceOffers -->
	<xs:element name="GetFinanceOffersResponse" type="ns:GetFinanceOffersResponseType"/>
	<xs:complexType name="GetFinanceOffersResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the number of finance offers and the current set of finance offers.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Count" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The number of finance offers available on the
								site and specified in the call request. If no
								finance offers exist that meet the request
								criteria, a count of 0 is returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFinanceOffers</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FinanceOfferArray" type="ns:FinanceOfferArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Set of currently available finance offers or a
								set that contains a specific finance offer (if a
								particular finance offer ID was specified in the
								call input). Only returned if finance offers
								meeting the request criteria exist.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetFinanceOffers</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetHighBidders -->
	<xs:element name="GetHighBiddersRequest" type="ns:GetHighBiddersRequestType"/>
	<xs:complexType name="GetHighBiddersRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a list of high bidders for the Dutch auction specified
				in the ItemID property of the request.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves a list of high bidders for the Dutch auction specified
						in the ItemId property of the request. A seller can use
						this list to determine which buyers
						are winning bidders and how many items each is able to purchase. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID that identifies the Dutch auction listing for which to
								retrieve a list of the high bidders.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetHighBidders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetHighBidders -->
	<xs:element name="GetHighBiddersResponse" type="ns:GetHighBiddersResponseType"/>
	<xs:complexType name="GetHighBiddersResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns a list of high bidders for the Dutch auction specified in the
				ItemId property of the request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="BidArray" type="ns:OfferArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of zero, one, or multiple OfferType objects. Each
								OfferType object represents the data for one high bidder. See the schema
								documentation for OfferType for details on its properties and their
								meanings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetHighBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ListingStatus" type="ns:ListingStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Specifies an active or ended listing's status in eBay's processing workflow.
							If a listing ends with a sale (or sales), eBay needs to update the sale details 
							(e.g., winning bidder) and other information. This processing 
							can take several minutes. If you retrieve a sold item, use this listing status information 
							to determine whether eBay has finished processing the listing so that you can 
							be sure the winning bidder and other details are correct and complete.
						</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetHighBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItem -->
	<xs:element name="GetItemRequest" type="ns:GetItemRequestType"/>
	<xs:complexType name="GetItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests data for a specific item identified by item ID. Use no
				DetailLevel to return all item fields without Item.Description.
				Use a DetailLevel of ReturnAll to return all item fields. See
				GetItem in the eBay Web Services Guide for more information.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests data for a specific item identified by item ID.
						Data returned includes title, description,
						minimum bid price, seller information, high bidder information (if there currently is a high bidder),
						and shipping specifications (if the seller elected to have the buyer pay for shipping). 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the item ID that uniquely identifies the item listing for which
								to retrieve the data. ItemID is a required input.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeWatchCount" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates if the caller wants to include watch count for that item in the response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeCrossPromotion" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates if the caller wants to include cross promotions for that item in the response. Default is set to true for backward compatibility.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItem -->
	<xs:element name="GetItemResponse" type="ns:GetItemResponseType"/>
	<xs:complexType name="GetItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the item data returned by the call. The data for the specified item
				listing is returned in an ItemType object.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ItemType object that contains the data for the specified item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItem</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemRecommendations -->
	<xs:element name="GetItemRecommendationsRequest" type="ns:GetItemRecommendationsRequestType"/>
	<xs:complexType name="GetItemRecommendationsRequestType">
		<xs:annotation>
			<xs:documentation>
				Examines potential item data that a seller
				has specified and returns recommended changes or opportunities for
				improvement. The types of recommendations returned for a given
				item can be configured by choosing one or more recommendation
				engines in the request. This call supports batch requests. That
				is, you can retrieve recommendations for multiple items at once.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Examines potential item data that a seller
						has specified and returns recommended changes or opportunities for
						improvement.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="GetRecommendationsRequestContainer" type="ns:GetRecommendationsRequestContainerType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Specifies the data for a single item and configures the recommendation engines to use
								when processing the item.
								To retrieve recommendations for multiple items, pass a separate
								GetRecommendationsRequestContainer for each item. In this case,
								pass a user-defined correlation ID for each item to identify the matching response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemRecommendations</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemRecommendations -->
	<xs:element name="GetItemRecommendationsResponse" type="ns:GetItemRecommendationsResponseType"/>
	<xs:complexType name="GetItemRecommendationsResponseType">
		<xs:annotation>
			<xs:documentation>
GetItemRecommendations returns recommended changes or opportunities for improvement 
related to listing data that was passed in the request.
This call supports batch requests. That is, it can retrieve recommendations for multiple 
items at once.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="GetRecommendationsResponseContainer" type="ns:GetRecommendationsResponseContainerType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
                  Specifies recommended changes or opportunities for improving the data of a single item.
                  If multiple items were processed, a separate GetRecommendationsResponseContainer
                  is returned for each item. Each container includes a user-defined correlation ID 
                  to help you match items in the request to recommendations in the response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemRecommendations</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemShipping -->
	<xs:element name="GetItemShippingRequest" type="ns:GetItemShippingRequestType"/>
	<xs:complexType name="GetItemShippingRequestType">
		<xs:annotation>
			<xs:documentation>
				Contains the input necessary to determine shipping information
				for an item.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns shipping cost estimates for an item.
						This is analogous to the Shipping Calculator seen in both the buyer and seller web pages.
						It is another way for a buyer or seller to obtain shipping cost information for
						an existing item (for which the caller is either the buyer or seller)
						at any point in the life of of the listing, before or after a buyer has committed to purchasing the item(s).
						This enables the user to determine the costs associated with a particular
						shipping service shipping to a specified postal code.
						(Note, however, that shipping insurance cost can only be determined once the final item price is known.) 
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Getting Shipping Cost Information</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The item ID that uniquely identifies the item listing for which
								to retrieve the data. Required input.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetItemShipping</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="QuantitySold" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number of items sold to a single buyer and to be shipped together.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemShipping</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DestinationPostalCode" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Destination country postal code (or zipcode, for US). Ignored if no
								country code is provided. Optional tag for some countries. More likely to
								be required for large countries.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemShipping</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DestinationCountryCode" type="ns:CountryCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Destination country code. If DestinationCountryCode is US,
								postal code is required and represents US zip code.
							</xs:documentation>
							<xs:appinfo>
								<Default>US</Default>
								<CallInfo>
									<CallName>GetItemShipping</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemShipping -->
	<xs:element name="GetItemShippingResponse" type="ns:GetItemShippingResponseType"/>
	<xs:complexType name="GetItemShippingResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the data returned by the call. The shipping
				details for the specified item are returned in a
				ShippingDetails object.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ShippingDetails" type="ns:ShippingDetailsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Shipping-related details for the specified item. Any error about shipping services
								(returned by a vendor of eBay's who calculates shipping costs) is returned in
								ShippingRateErrorMessage. Errors from a shipping service are likely to be related to
								issues with shipping specifications, such as package size and the selected shipping
								method not supported by a particular shipping service.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemShipping</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemTransactions -->
	<xs:element name="GetItemTransactionsRequest" type="ns:GetItemTransactionsRequestType"/>
	<xs:complexType name="GetItemTransactionsRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns the transactions associated with the sale of one or more items. A
				transaction contains the information about the sale of one or more items by one
				buyer from a single listing. GetItemTransactions retrieves a report containing
				information you can use to process one listing's transactions. (Often, it is more
				efficient to use GetSellerTransactions instead. See the reference guide for more
				information.) As some listings can return large numbers of transactions, use the
				supplied time filters to retrieve only those transactions whose status has been
				modified between two dates. Optionally, also configure the request to retrieve one
				page of data at a time (where each page contains a more manageable number of
				transactions). All the listing's transactions that were modified within the
				specified date range can be retrieved, or a single transaction can be retrieved.
				However, retrieving transactions one at a time is inefficent and requires more API
				calls.
				&lt;br&gt;&lt;br&gt;
				In general, only fields that are necessary for processing transactions are
				returned. For example, reserve price information would not be returned because the
				data is not relevant once the agreement to purchase the item has occurred. Also,
				fields that are not logically applicable are not returned. For example,
				TransactionArray.Transaction.Buyer.SellerInfo is not returned because the buyer is
				not acting in the role of a seller for the transaction.
				&lt;br&gt;&lt;br&gt;
				As the ItemType object is returned at the root level of the response, and as all
				transactions returned from this call are from the same item, each individual
				TransactionType object does not return an ItemType object.
				&lt;br&gt;&lt;br&gt;
				Notes:
				&lt;br&gt;
				- In the TransactionArray.Transaction.ShippingDetails object, only one of
				FlatShippingRate or CalculatedRate will be returned, depending on which one the
				seller set.
				&lt;br&gt;
				- In the Item.Buyer and Item.Seller objects, email and address data is only
				returned under certain conditions.
				&lt;br&gt;
				- The Item.ListingDetails.RelistedItemID object is only returned if the item was
				re-listed.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves data for transactions created by the sale
						of items from a single, specified listing. Input is the
						item ID for the item that spawned the transactions. GetItemTransactions
						returns zero, one, or multiple transactions (depending on the sale of
						items from the listing and the listing type). The result set can include
						only the transactions created between two specified dates. 
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
				<SeeLink>
					<Title>Email and Address Privacy Policy</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=EmailPrivacyPolicy</URL>
					<For>the conditions under which buyer and seller email and address are returned</For>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID for the item for which to retrieve transactions.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the earliest (oldest) date to use in a date range filter based on the
								time the transaction status was modified. Filters out transactions whose status was
								last modified before this date. The date range between ModTimeFrom to ModTimeTo
								cannot be greater than 30 days.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the latest (most recent) date to use in a date range filter based on the
								time a transaction's status was modified. Filters out transactions whose status
								was last modified after this date. The date range between ModTimeFrom to ModTimeTo
								cannot be greater than 30 days. It is considered a best practice to always pass
								the current date-time, to ensure that no data is missed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Identifies one transaction for a listing.
								For Chinese auctions listings (single-item listings for which there can be
								only one transaction), TransactionID is always 0, and for multi-quantity
								listings (for which there can be multiple transactions), TransactionID has
								a non-0 value.
								To determine the valid transaction IDs
								for a listing, you typically need to have previously executed GetItemTransactionsCall
								or GetSellerTransactionsCall and stored all the listing's transactions.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements control pagination of the output. Use its EntriesPerPage
								property to control the number of transactions to return per call and its
								PageNumber property to specify the page of data to return.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeFinalValueFee" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether to include final value fees in the response.
								For most listing types, the fee is returned in Transaction.FinalValueFee.
								For Dutch auctions that end with bids (not Buy It Now purchases), the fee
								is returned in Item.SellingStatus.FinalValueFee.
								The Final Value Fee for FixedPriceItem, StoresFixedPrice, and Buy It Now
								Dutch listing types is returned on a transaction by transaction basis.
								For all other listing types, including Chinese and Dutch (no Buy It Now
								purchases), the Final Value Fee is returned when the listing status is
								Completed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeContainingOrder" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								For future use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemTransactions -->
	<xs:element name="GetItemTransactionsResponse" type="ns:GetItemTransactionsResponseType"/>
	<xs:complexType name="GetItemTransactionsResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns an array of transaction data for the item specified in the request.
				The results can be used to create a report of data that is commonly
				necessary for end-of-auction processing.
				Zero, one, or many Transaction objects can be returned in the array.
				The set of transactions returned is limited to those that were modified between
				the times specified in the request's ModTimeFrom and ModTime filters.
				Also returns the item object that spawned the transactions.
				If pagination filters were specified in the request, returns meta-data describing
				the effects of those filters on the current response and the estimated effects if
				the same filters are used in subsequent calls.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the total number of pages (TotalNumberOfPages) and the total number
								of entries (TotalNumberOfEntries) that could be returned given repeated calls
								that use the same selection criteria as the call that returned this response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreTransactions" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether there are additional transactions to retrieve.
								That is, indicates whether more pages of data are available to be
								returned, given the filters that were specified in the request.
								Returns false for the last page of data.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number of transactions returned per page (per call). May be a higher value
								than ReturnedTransactionCountActual if the page returned is the last page
								and more than one page of data exists.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Page number for the page of transactions the response returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReturnedTransactionCountActual" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number of transactions retrieved in the current page of results just returned.
								May be a lower value than TransactionsPerPage if the page returned is the last
								page and more than one page of data exists.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Item object that spawned the transaction. It is a purchase from this item's listing
								that the transaction represents.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionArray" type="ns:TransactionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								List of Transaction objects representing the transactions resulting
								from the listing. Each Transaction object contains the data for one purchase
								(of one or more items in the same listing). The Transaction.Item field is not
								returned because the Item object is returned at the root level of the response.
								See the reference guide for more information about the fields that are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PayPalPreferred" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether the item's seller has the preference enabled that shows that the seller
								prefers PayPal as the method of payment for an item. This preference is indicated on
								an item's View Item page and is intended to influence a buyer to use PayPal
								to pay for the item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemsAwaitingFeedback -->
	<xs:element name="GetItemsAwaitingFeedbackRequest" type="ns:GetItemsAwaitingFeedbackRequestType"/>
	<xs:complexType name="GetItemsAwaitingFeedbackRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests items awaiting feedback from the user's My eBay account.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests items awaiting feedback from the user's My eBay account.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractRequestType">
				<xs:sequence>
					<xs:element name="Sort" type="ns:ItemSortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how the returned feedback items should be sorted. Valid values
								are Title, TitleDescending, UserID, UserIDDescending, EndTime, EndTimeDescending,
								FeedbackReceived, FeedbackReceivedDescending, FeedbackLeft, and
								FeedbackLeftDescending.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemsAwaitingFeedback</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the number of entries per page and the page number to return
								in the result set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemsAwaitingFeedback</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetItemsAwaitingFeedback -->
	<xs:element name="GetItemsAwaitingFeedbackResponse" type="ns:GetItemsAwaitingFeedbackResponseType"/>
	<xs:complexType name="GetItemsAwaitingFeedbackResponseType">
		<xs:annotation>
			<xs:documentation>
				(out) Returns items from a user's My eBay account that
				do not yet have feedback.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemsAwaitingFeedback" type="ns:PaginatedTransactionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Contains the items awaiting feedback.
								Returned only if there are items that do not yet
								have feedback.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetItemsAwaitingFeedback</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetLiveAuctionBidders -->
	<xs:element name="GetLiveAuctionBiddersRequest" type="ns:GetLiveAuctionBiddersRequestType"/>
	<xs:complexType name="GetLiveAuctionBiddersRequestType">
		<xs:annotation>
			<xs:documentation>
				Includes the list of bidders for the requested catalog.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Gets a list of users who have
						signed up to participate in their auctions,
						including the bid approval status of each user. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="UserCatalogID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number that identifies the seller's eBay Live Auctions catalog for which they
								want to retrieve bidder requests.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BidderStatus" type="ns:BidderStatusCodeType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The seller can ask to retrieve a subset of users in the bidder approval list
								who are either "approved","denied", or "pending" or a combination of these.
								If this field is not specified in the request, all records are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements control pagination of the output.
								Use its EntriesPerPage property to control the number of bidders to return per call
								and its PageNumber property to specify the page of data to return.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetLiveAuctionBidders -->
<!-- W3C Schema generated by XMLSPY v5 rel. 4 U (http://www.xmlspy.com)
  -->
	<xs:element name="GetLiveAuctionBiddersResponse" type="ns:GetLiveAuctionBiddersResponseType"/>
	<xs:complexType name="GetLiveAuctionBiddersResponseType">
		<xs:annotation>
			<xs:documentation>
			Includes the list of bidders for the requested catalog.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>				
					<xs:element name="BidderDetails" type="ns:BidderDetailArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the bidder details that match the bidder query 
								passed in the request. 
								Returned when bidder search results are found.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>					
					<xs:element name="TotalPending" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Total number of bidders in Pending state.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TotalApproved" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Total number of bidders in Approved state.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TotalDenied" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Total number of bidders in Denied state.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							The page number for the page of data returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>					
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Shows the pagination of data returned by requests. Only returned
							if Pagination was specified in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionBidders</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetLiveAuctionCatalogDetails -->
	<xs:element name="GetLiveAuctionCatalogDetailsRequest" type="ns:GetLiveAuctionCatalogDetailsRequestType"/>
	<xs:complexType name="GetLiveAuctionCatalogDetailsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves all the eBay Live Auctions catalogs and upcoming sale
				schedules that the user has created. Only returns data if the
				requestor is an authorized eBay Live Auctions seller with at least
				one catalog. If the seller's auction house has no upcoming sales,
				no schedules are returned.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves all the eBay Live Auctions catalogs and upcoming
						sale schedules that the user has created.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetLiveAuctionCatalogDetails -->
	<xs:element name="GetLiveAuctionCatalogDetailsResponse" type="ns:GetLiveAuctionCatalogDetailsResponseType"/>
	<xs:complexType name="GetLiveAuctionCatalogDetailsResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns all the upcoming eBay Live Auctions catalogs and sale schedules that the user has created.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="LiveAuctionCatalog" type="ns:LiveAuctionCatalogType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Each eBay Live Auctions catalog describes one live auction catalog created by the user,
								along with one or more sale schedules.
								Use this information to determine an appropriate combination of catalog and schedule IDs
								in which to list lot items with AddLiveAuctionItem.
								Only returns details about catalogs that contain pending sales. 
								That is, if a catalog has no sales or all its sales have ended, 
								the catalog details are not returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetLiveAuctionCatalogDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMemberMessages -->
	<xs:element name="GetMemberMessagesRequest" type="ns:GetMemberMessagesRequestType"/>
	<xs:complexType name="GetMemberMessagesRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a list of the messages buyers have posted about your
				active item listings.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves messages
						posted to the
						Ask Seller A Question messaging system. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The ID of the message.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MailMessageType" type="ns:MessageTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The type of message.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MessageStatus" type="ns:MessageStatusTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The status of the message.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisplayToPublic" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies if the message should be displayed on the
								website with the item listing.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartCreationTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Used as beginning of date range filter.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndCreationTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Used as end of date range filter.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Standard pagination argument used to reduce response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MemberMessageID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An ID that uniquely identifies the message for a given user to be retrieved.
								Used for the AskSellerQuestion notification only.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMemberMessages -->
	<xs:element name="GetMemberMessagesResponse" type="ns:GetMemberMessagesResponseType"/>
	<xs:complexType name="GetMemberMessagesResponseType">
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="MemberMessage" type="ns:MemberMessageExchangeArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The returned member messages. Returned if messages that meet the request criteria exist.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Shows the pagination of data returned by requests.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreItems" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether the response has more items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMemberMessages</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyMessages -->
	<xs:element name="GetMyMessagesRequest" type="ns:GetMyMessagesRequestType"/>
	<xs:complexType name="GetMyMessagesRequestType">
		<xs:annotation>
			<xs:documentation>
				Used to retrieve information about the messages and alerts sent
				to a given user. Depending on the detail level, this information
				can include message and alert counts, resolution and flagged
				status, message and/or alert headers, and message and/or alert
				body text. Note that this call requires a DetailLevel in the
				request. Omitting the Detail Level returns an error.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves information about the messages and alerts sent to
						a given user.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AlertIDs" type="ns:MyMessagesAlertIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of up to 10 AlertID values.
								When AlertID values are used as input, you must
								generally specify either AlertID values, or
								MessageID values, or both.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MessageIDs" type="ns:MyMessagesMessageIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of up to 10 MessageID values.
								When MessageID values are used as input, you must
								generally specify either AlertID values, or
								MessageID values, or both.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FolderID" type="xs:long" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An ID that uniquely identifies the My Messages folder from which to retrieve alerts or messages.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyMessages</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyMessages -->
  <xs:element name="GetMyMessagesResponse" type="ns:GetMyMessagesResponseType"/>
	<xs:complexType name="GetMyMessagesResponseType">
		<xs:annotation>
			<xs:documentation>
			Conains information about the messages and alerts sent to
			a given user. Depending on the detail level, this
			information can include message and alert counts,
			resolution and flagged status, message and/or alert
			headers, and message and/or alert body text.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Summary" type="ns:MyMessagesSummaryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Summary data for a given user's alerts and
								messages. This includes the numbers of
								new alerts and messages, unresolved alerts,
								flagged messages, and total alerts and messages.
								The amount and type of data returned is the same
								whether or not the request included specific
								AlertID or MessageID values.
								Always/Conditionally returned logic assumes a
								detail level of ReturnMessages.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyMessages</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnSummary</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Alerts" type="ns:MyMessagesAlertArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the alert information for each alert
								specified in AlertIDs. The amount and type of
								information returned varies based on the
								requested detail level. Contains one
								MyMessagesAlertType object per alert. Returned
								as an empty node if user has no alerts.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyMessages</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Messages" type="ns:MyMessagesMessageArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the message information for each
								message specified in MessageIDs. The amount and
								type of information returned varies based on the
								requested detail level. Contains one
								MyMessagesMessageType object per message.
								Returned as an empty node if user has no
								messages.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyMessages</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBay -->
  <xs:element name="GetMyeBayRequest" type="ns:GetMyeBayRequestType"/>
  <xs:complexType name="GetMyeBayRequestType">
    <xs:annotation>
      <xs:documentation>
				GetMyeBay will be DEPRECATED SOON and should not be used.
				Instead, please use GetMyeBayBuying and related calls to retrieve
				a users's My eBay data. Retrieves data for the requesting user's
				My eBay page. This data includes a list of items the user is
				watching and a list of items the user has bid on. You must
				specify at least one field in the request to receive data in the
				response. In addition, you must include at least one sort field -
				BiddingSort, LostSort, WatchSort, or WonSort.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						To be deprecated. Use GetMyeBayBuying and related calls.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="BiddingSort" type="ns:ItemSortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how the items in the active list (the items the user has bid
								on) are sorted in the result set. The items may be sorted by item ID,
								price, title, bid count, and listing end time. See the code list
								ItemSortTypeCodeType for valid input values.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBay</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LostSort" type="ns:ItemSortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how the items in the lost list (items the user has bid on but has
								not won) are sorted in the result set. The items may be sorted by item ID,
								price, title, bid count, and listing end time. See the code list
								ItemSortTypeCodeType for valid input values.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBay</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MaxItemsPerList" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies maximum number of items to display in each of the lists.
								Recommended value is 5. If not specified, all possible items for each
								list are returned. One maximum is specified and applies to all of the
								lists in the result set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBay</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MaxItemAgeInDays" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the number of days prior to the current time (based on item
								end time) to retrieve items. Applies only to the items won and items
								lost lists. Default value is 2. Maximum value is 30.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBay</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WatchSort" type="ns:ItemSortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how the items in the watch list (the items the user is watching)
								are sorted in the result set. The valid values of ItemSortTypeCodeType
								are ItemID, ItemIDDescending, Price, PriceDescending,
								BidCount, BidCountDescending, SellerUserID, SellerUserIDDescending,
								TimeLeft, and TimeLeftDescending.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBay</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WonSort" type="ns:ItemSortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how the items in the won list (the items the user has won)
								are sorted in the result set. The items may be sorted by item ID,
								price, title, bid count, and listing end time. See the code list
								ItemSortTypeCodeType for valid input values.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBay</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FavoriteSearches" type="ns:MyeBaySelectionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                A user's favorite eBay searches. Corresponds to the Searches selection under All Favorites
                on the My eBay page.
              </xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="FavoriteSellers" type="ns:MyeBaySelectionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                A user's favorite eBay sellers. Corresponds to the Sellers selection under All Favorites
                on the My eBay page.
              </xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="SecondChanceOffers" type="ns:MyeBaySelectionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                Second Chance Offers for items. Corresponds to the Second Chance Offers listed
                on the My eBay page.
              </xs:documentation>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBay -->
  <xs:element name="GetMyeBayResponse" type="ns:GetMyeBayResponseType"/>
  <xs:complexType name="GetMyeBayResponseType">
    <xs:annotation>
      <xs:documentation>
GetMyeBay will be DEPRECATED SOON and should not be used. Instead, please use 
GetMyeBayBuying and related calls to retrieve a users's My eBay data.
Contains the lists of items from the requesting user's My
eBay page. This includes a list of the items the user has bid
on and a list of the items the user is watching. The number of
items returned in any list can be controlled using the MaxItemsPerList
property of the request object.
			</xs:documentation>
    </xs:annotation>
    <xs:complexContent>
      <xs:extension base="ns:AbstractResponseType">
        <xs:sequence>
          <xs:element name="BiddingItemArray" type="ns:ItemArrayType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
                  Contains the list of items the requesting user has bid on. BiddingItemArray is
                  an array of ItemType objects, each of which represents one item.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:element name="LostItemArray" type="ns:ItemArrayType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
								Contains the list of items the requesting user has bid on but not has won. 
								LostItemArray is an array of ItemType objects, each of which represents one item.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:element name="WatchItemArray" type="ns:ItemArrayType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
								Contains the list of items the requesting user is watching. WatchItemArray is
								an array of ItemType objects, each of which represents one item.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:element name="WonItemArray" type="ns:ItemArrayType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
								Contains the list of items the requesting user has won. WonItemArray is
								an array of ItemType objects, each of which represents one item.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:element name="FavoriteSearches" type="ns:MyeBayFavoriteSearchListType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
								Contains a list of the user's My eBay Favorite Searches.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:element name="FavoriteSellers" type="ns:MyeBayFavoriteSellerListType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
								Contains a list of the user's My eBay Favorite Sellers.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:element name="SecondChanceOffers" type="ns:MyeBaySecondChanceOfferListType" minOccurs="0">
            <xs:annotation>
              <xs:documentation>
								Contains a list of the user's My eBay Second Chance Offers.
							</xs:documentation>
              <xs:appinfo>
                <CallInfo>
                  <CallName>GetMyeBay</CallName>
									<Returned>Conditionally</Returned>
                </CallInfo>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
	<!--  Call: GetMyeBayBuying -->
	<xs:element name="GetMyeBayBuyingRequest" type="ns:GetMyeBayBuyingRequestType"/>
	<xs:complexType name="GetMyeBayBuyingRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns items from the All Buying section of the user's My eBay
				account, including items the user is watching, bidding on, has
				won, has not won, or has made best offers on. Use DetailLevel of
				ReturnSummary to return only the BuyingSummary and the specific
				containers requested. The DetailLevel ReturnAll returns the
				BuyingSummary and all containers.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns items from the All Buying section of the user's My eBay
						account, including items the user is watching, bidding on, has
						won, has not won, or has made best offers on.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractRequestType">
				<xs:sequence>
					<xs:element name="WatchList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of watched items in the user's My eBay list. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BidList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of items bid on in the user's My eBay list.
								Allowed values are Sort and IncludeNotes.Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BestOfferList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of items on which the user has placed best offers.
								Allowed values are Include, ListingType, Sort, DurationInDays (0-60 valid), IncludeNotes, and
								Pagination. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WonList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of items bid on and won in the user's My eBay list.
								Allowed values are DurationInDays (valid values 0-60), Sort, IncludeNotes, and Pagination. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LostList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of items bid on and lost in the user's My eBay list.
								Allowed values are DurationInDays (valid values 0-60), Sort, IncludeNotes,
								and Pagination. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FavoriteSearches" type="ns:MyeBaySelectionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of favorite searches in the user's My eBay list.
								All values are allowed. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FavoriteSellers" type="ns:MyeBaySelectionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of favorite sellers in the user's My eBay list.
								All values are allowed. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
					  </xs:annotation>
					</xs:element>
					<xs:element name="SecondChanceOffer" type="ns:MyeBaySelectionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies how to return the list of second chance offers in the user's My eBay list.
								All values are allowed. Include in the request to return this container at a DetailLevel of ReturnSummary.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
					  </xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBayBuying -->
	<xs:element name="GetMyeBayBuyingResponse" type="ns:GetMyeBayBuyingResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns items from All Buying or All Favorites in the user's GetMyeBay account.
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GetMyeBayBuyingResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns items from All Buying or All Favorites in the user's My eBay account.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractResponseType">
				<xs:sequence>
					<xs:element name="BuyingSummary" type="ns:BuyingSummaryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a summary of the items the user has bid on. Returned at all detail levels.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WatchList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user is watching. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BidList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains all the items the user has bid on. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BestOfferList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user has placed best offers on. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WonList" type="ns:PaginatedOrderTransactionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user has bid on and won. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LostList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user has bid on and lost. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FavoriteSearches" type="ns:MyeBayFavoriteSearchListType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of the user's favorite searches. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FavoriteSellers" type="ns:MyeBayFavoriteSellerListType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of the user's favorite sellers. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SecondChanceOffer" type="ns:ItemType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Contains the list of second chance offers the user has received. Only returned if items exist that meet the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayBuying</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBayReminders -->
	<xs:element name="GetMyeBayRemindersRequest" type="ns:GetMyeBayRemindersRequestType"/>
	<xs:complexType name="GetMyeBayRemindersRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests reminder type totals from the user's MyeBay account.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests totals of various reminder types from the user's
						MyeBay account.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractRequestType">
				<xs:sequence>
					<xs:element name="BuyingReminders" type="ns:ReminderCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the type of buying reminders for which you want information.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayReminders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellingReminders" type="ns:ReminderCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the type of selling reminders for which you want information.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayReminders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBayReminders -->
	<xs:element name="GetMyeBayRemindersResponse" type="ns:GetMyeBayRemindersResponseType">
		<xs:annotation>
			<xs:documentation>
			Returns totals of various reminder types from the user's My eBay account.
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GetMyeBayRemindersResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns totals of various reminder types from the user's My eBay account.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractResponseType">
				<xs:sequence>
					<xs:element name="BuyingReminders" type="ns:RemindersType" minOccurs="0">
						<xs:annotation>
								<xs:documentation>
									(out) Contains the buying reminders in the user's My eBay account that match
									the request criteria.
								</xs:documentation>
								<xs:appinfo>
									<CallInfo>
										<CallName>GetMyeBayReminders</CallName>
										<Returned>Conditionally</Returned>
									</CallInfo>
								</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellingReminders" type="ns:RemindersType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Contains the selling reminders in the user's My eBay account that match
								the request criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBayReminders</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBaySelling -->
	<xs:element name="GetMyeBaySellingRequest" type="ns:GetMyeBaySellingRequestType"/>
	<xs:complexType name="GetMyeBaySellingRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns a summary and details of items a user is selling from the
				user's My eBay account. Use no DetailLevel to return
				SellingSummary and any containers specified in the request. The
				DetailLevel ReturnAll returns SellingSummary and all containers.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns a summary and details of items a user is selling from the
						user's My eBay account.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractRequestType">
				<xs:sequence>
					<xs:element name="ScheduledList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the list of items the user has scheduled to sell but whose listings have not yet opened.
								Valid subelements are Sort, IncludeNotes, and Pagination.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBaySelling</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ActiveList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the list of items the user is actively selling whose listings are active.
								Valid subelements are Sort, IncludeNotes, Pagination, and ListingType (with valid
								values Auction, FixedPriceItem, StoresFixedPrice, or AdType).
								Note that if a DetailLevel of ReturnAll is specified in the request, this element is ignored as a way to filter the response, and ALL containers are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBaySelling</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SoldList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the list of items the user has sold. Valid subelements are DurationInDays
								(with valid values 0-60), IncludeNotes, and Pagination.
								Note that if a DetailLevel of ReturnAll is specified in the request, this element is ignored as a way to filter the response, and ALL containers are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBaySelling</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UnsoldList" type="ns:ItemListCustomizationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the list of items the user has listed but whose listings have ended
								without being sold. Valid subelements are DurationInDays (with valid values 0-60),
								Sort, IncludeNotes, and Pagination.
								Note that if a DetailLevel of ReturnAll is specified in the request, this element is ignored as a way to filter the response, and ALL containers are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBaySelling</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetMyeBaySelling -->
	<xs:element name="GetMyeBaySellingResponse" type="ns:GetMyeBaySellingResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns summary and detail information about items the user is selling,
				items scheduled to sell, currently listed, sold, and closed but not sold.
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GetMyeBaySellingResponseType">
			<xs:annotation>
				<xs:documentation>
					Returns summary and detail information about items the user is selling,
					items scheduled to sell, currently listed, sold, and closed but not sold.
				</xs:documentation>
			</xs:annotation>
		<xs:complexContent>
			<xs:extension base="AbstractResponseType">
				<xs:sequence>
					<xs:element name="SellingSummary" type="ns:SellingSummaryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains summary information about the items the user is selling.
							</xs:documentation>
							<xs:appinfo>
							<CallInfo>
								<CallName>GetMyeBaySelling</CallName>
								<Returned>Always</Returned>
							</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ScheduledList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user has scheduled for sale, but whose listings have
								not yet started.
							</xs:documentation>
							<xs:appinfo>
							<CallInfo>
								<CallName>GetMyeBaySelling</CallName>
								<Returned>Conditionally</Returned>
							</CallInfo>
						</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ActiveList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user is selling that have active listings.
							</xs:documentation>
							<xs:appinfo>
							<CallInfo>
								<CallName>GetMyeBaySelling</CallName>
								<Returned>Conditionally</Returned>
							</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SoldList" type="ns:PaginatedOrderTransactionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items the user has sold.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBaySelling</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UnsoldList" type="ns:PaginatedItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the items whose listings have ended but that have not sold.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetMyeBaySelling</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetNotificationPreferences -->
	<xs:element name="GetNotificationPreferencesRequest" type="ns:GetNotificationPreferencesRequestType"/>
	<xs:complexType name="GetNotificationPreferencesRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the requesting application's notification preferences.
				GetNotificationPreferences retrieves preferences that you have
				deliberately set. For example, if you enable the EndOfAuction
				event and then later disable it, the response shows the
				EndOfAuction event preference as Disabled. But if you have never
				set a preference for the EndOfAuction event, no EndOfAuction
				preference is returned at all.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the requesting application's notification preferences.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="PreferenceLevel" type="ns:NotificationRoleCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies what type of Preference to retrieve.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationPreferences</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetNotificationPreferences -->
	<xs:element name="GetNotificationPreferencesResponse"  type="ns:GetNotificationPreferencesResponseType"/>
	<xs:complexType name="GetNotificationPreferencesResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the requesting application's notification preferences.
				GetNotificationPreferences retrieves preferences that you have
				deliberately set. For example, if you enable the EndOfAuction event and
				then later disable it, the response shows the EndOfAuction event
				preference as Disabled. But if you have never set a preference for the
				EndOfAuction event, no EndOfAuction preference is returned at all.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ApplicationDeliveryPreferences" type="ns:ApplicationDeliveryPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Specifies application-based event preferences that have been enabled.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserDeliveryPreferenceArray" type="ns:NotificationEnableArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) Specifies user-based event preferences that have been enabled or disabled.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserData" type="ns:NotificationUserDataType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) return user data for notification settings such as set mobile phone number etc.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EventProperty" type="ns:NotificationEventPropertyType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								(out) Characteristics or details of an event such as type, name and value.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetNotificationsUsage -->
	<xs:element name="GetNotificationsUsageRequest" type="ns:GetNotificationsUsageRequestType"/>
	<xs:complexType name="GetNotificationsUsageRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves information about notifications sent to a given application. The
				application (AppID) is determined the requester credentials. Use this
				notification information to troubleshoot issues with platform notifications.
				Developers can make up to 50 GetNotificationsUsage calls per hour for a
				given application.
			</xs:documentation>
		<xs:appinfo>
			<Overview>
				<Summary>
					Retrieves information about platform notifications sent to a given application.
				</Summary>
			</Overview>
		</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the start date and time for which notification information
								will be retrieved. StartTime is optional. If no StartTime is specified,
								the default value of 24 hours prior to the call time is used. If no
								StartTime is specified or if an invalid StartTime is specified, date
								range errors are returned in the response. For a StartTime to be valid,
								it must be no more than 72 hours before the time of the call, it cannot
								be more recent than the EndTime, and it cannot be later than the time of
								the call. If an invalid StartTime is specified, the default value is
								used.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the end date and time for which notification information
								will be retrieved. EndTime is optional. If no EndTime is specified,
								the current time (the time the call is made) is used. If no EndTime
								is specified or if an invalid EndTime is specified, date range errors
								are returned in the response. For an EndTime to be valid, it must be no
								more than 72 hours before the time the of the call, it cannot be before
								the StartTime, and it cannot be later than the time of the call. If an
								invalid EndTime is specified, the current time is used.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies an item ID for which detailed notification information will be
								retrieved. ItemID is optional. If no ItemID is specified, the response
								will not include any individual notification details.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetNotificationsUsage -->
	<xs:element name="GetNotificationsUsageResponse" type="ns:GetNotificationsUsageResponseType"/>
	<xs:complexType name="GetNotificationsUsageResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns an array of notifications sent to a given application identified by the appID
				(comes in the credentials). The result can be used by third-party developers troubleshoot
				issues with notifications.
				Zero, one or many notifications can be returned in the array. The set of notifications
				returned is limited to those that were sent between the StartTime and EndTime specified
				in the request. If StartTime or EndTime filters were not found in the request, then
				the response will contain the data for only one day (Now-1day). By default, maximum
				duration is limited to 3 days (Now-3days). These min (1day) and max(3days) applies
				to Notifications,MarkDownMarkUpHistory and NotificationStatistics.

				Notifications are sent only if the ItemID is included in the request. If there is no
				ItemID, then only Statistics and MarkDownMarkUpHistory information is included.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Returns the start date and time for the notification information that is
								returned by this call. The oldest date allowed for this field is Now-3days.
								Default is Now-1day.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Returns the end date and time for the notification information that is
								returned by this call. The default is Now.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="NotificationDetailsArray" type="ns:NotificationDetailsArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								List of notification objects representing the notifications sent to an 
								application for the given time period. It will only be returned if ItemID 
								was specified in the input request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MarkUpMarkDownHistory" type="ns:MarkUpMarkDownHistoryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								List of objects representing MarkUp or MarkDown history for a given appID
								and for given StartTime and EndTime. This node will always be returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="NotificationStatistics" type="ns:NotificationStatisticsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Summary information about number of notifications that were successfully
								delivered, queued, failed, connection attempts made, connection timeouts,
								http errors for the given appID and given time period. By default, statistics
								for only one day (Now-1day) is included. Maximum time duration allowed is 3 days
								(Now-3days).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetNotificationsUsage</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetOrderTransactions -->
	<xs:element name="GetOrderTransactionsRequest" type="ns:GetOrderTransactionsRequestType"/>
	<xs:complexType name="GetOrderTransactionsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves information about one or more orders or one or more transactions
				(or both), thus displacing the need to call GetOrders and GetItemTransactions
				separately.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves information about one or more orders or one or more
						transactions (or both). You can use GetOrderTransactions instead of
						making separate GetOrders and GetItemTransactions calls.
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemTransactionIDArray" type="ns:ItemTransactionIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An array of ItemTransactionIDs.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrderTransactions</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderIDArray" type="ns:OrderIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An array of OrderIDs.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrderTransactions</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetOrderTransactions -->
	<xs:element name="GetOrderTransactionsResponse" type="ns:GetOrderTransactionsResponseType"/>
	<xs:complexType name="GetOrderTransactionsResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to GetOrderTransactions request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="OrderArray" type="ns:OrderArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An array of Orders.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrderTransactions</CallName>
									<DetailLevels>none</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetOrders -->
	<xs:element name="GetOrdersRequest" type="ns:GetOrdersRequestType"/>
	<xs:complexType name="GetOrdersRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves all of the orders for which the user is a participant (as
				either buyer or seller) that meet the criteria specified in the request
				object.
				There are two mutually exclusive sets of filtering input arguments
				that can be used to query for orders. The first set is based on specific
				order IDs (one or more order IDs are passed in the call). The second set
				is a combination of date range, order role, and order status. If one set
				of filtering arguments is used, the arguments for the other set should not
				be specified in the same call. If a given call to GetOrders includes both
				criteria sets, the query based on order IDs is used, and the criteria for
				date range/order status/order role is ignored.
				This call can also be used to retrieve unshipped Half.com orders (i.e.,
				orders that the seller has received but has not yet processed).
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves all of the orders for which the user is a participant (as
						either buyer or seller) that meet the criteria specified in the request
						object.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="OrderIDArray" type="ns:OrderIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A set of orders to retrieve.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CreateTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The starting date of the date range for the orders to retrieve.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CreateTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The ending date of the date range for the orders to retrieve.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderRole" type="ns:TradingRoleCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Filters the returned orders to only those where the user for
								whom the call is being made is a participant in the order in the specified role.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderStatus" type="ns:OrderStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Filters the returned orders by order status. &lt;br&gt;
								&lt;br&gt;
								Not applicable to Half.com. If you set ListingType to Half and you
								include OrderStatus in the request, GetOrders may return incomplete information
								or have indeterminate results. Therefore, please do not specify OrderStatus
								when you retrieve Half.com orders.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ListingType" type="ns:ListingTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Cannot be used as a filter on eBay.com. If not provided or if any value other than Half is specified,
								the call retrieves eBay orders. If Half is specified,
								the call retrieves Half.com orders. (You cannot retrieve both
								eBay and Half.com orders in the same response.)
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Not applicable to eBay.com. Applicable to Half.com. If many orders are available,
							you may need to call GetOrders multiple times to retrieve all the data.
							Each result set is returned as a page of entries.
							Use this Pagination information to indicate the maximum number of entries to
							retrieve per page (i.e., per call), the page number to retrieve, and other data.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetOrders -->
	<xs:element name="GetOrdersResponse" type="ns:GetOrdersResponseType"/>
	<xs:complexType name="GetOrdersResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the set of orders that match the order IDs or filter criteria specified.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Applies only to Half.com. Contains information regarding the pagination of data (if pagination is used),
							including total number of pages and total number of entries. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreOrders" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Applies only to Half.com. If true, there are more orders yet to be retrieved. Additional GetOrders calls
							with higher page numbers or more entries per page must be made to retrieve these orders.
							If false, no more orders are available or no orders match the request
							(based on the input filters).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderArray" type="ns:OrderArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The set of orders that match the order IDs or filter criteria specified.
								Also applicable to Half.com (only returns orders that have not been marked as shipped).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrdersPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Applies only to Half.com. Indicates the number of orders that can be returned per page of data
							(i.e., per call). This is the same as the value specified in the Pagination.EntriesPerPage input
							(or the default value, if EntriesPerPage was not specified).
							This is not necessarily the actual number of orders returned per page (see ReturnedOrderCountActual).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Applies only to Half.com. Indicates which page of data holds the current result set. Will be the same as the value specified in the Pagination.PageNumber input. If orders are returned, the first page is 1.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReturnedOrderCountActual" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Applies only to Half.com. Indicates the total number of orders returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetOrders</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPictureManagerDetails -->
	<xs:element name="GetPictureManagerDetailsRequest" type="ns:GetPictureManagerDetailsRequestType"/>
	<xs:complexType name="GetPictureManagerDetailsRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests information about folders or pictures in a Picture Manager account
				or the account settings.
	    </xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests information about folders or pictures in a Picture
						Manager account or the account settings.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="FolderID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The ID of a folder in the user's Picture Manager album for which you want information.
								If you specify both FolderID and PictureURL, the picture must exist
								in the folder.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPictureManagerDetails</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PictureURL" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The URL of a picture in the user's Picture Manager album.
								If you specify both FolderID and PictureURL, the picture must
								exist in the folder.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPictureManagerDetails</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PictureManagerDetailLevel" type="ns:PictureManagerDetailLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The type of information you want returned, about pictures and folders,
								the account subscription, or both. Use this element rather than the generic DetailLevel element defined in AbstractRequestType. You can use the following values: ReturnAll, ReturnSubscription, or ReturnPicture.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPictureManagerDetails</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPictureManagerDetails -->
	<xs:element name="GetPictureManagerDetailsResponse" type="ns:GetPictureManagerDetailsResponseType"/>
	<xs:complexType name="GetPictureManagerDetailsResponseType">
		<xs:annotation>
			<xs:documentation>
				Responds with information about content in a Picture Manager album
				or the account settings.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PictureManagerDetails" type="ns:PictureManagerDetailsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains details of the account settings, folders or
								pictures in the user's album, or both.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPictureManagerDetails</CallName>
									<DetailLevels>none, ReturnSubscription, ReturnPicture, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPictureManagerOptions -->
	<xs:element name="GetPictureManagerOptionsRequest" type="ns:GetPictureManagerOptionsRequestType"/>
	<xs:complexType name="GetPictureManagerOptionsRequestType">
		<xs:annotation>
			<xs:documentation>
	      Requests a list of Picture Manager options and allowed values,
				such as subscription type and picture display.
	    </xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests a list of Picture Manager options and allowed values,
						such as subscription type and picture display.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPictureManagerOptions -->
	<xs:element name="GetPictureManagerOptionsResponse" type="ns:GetPictureManagerOptionsResponseType"/>
	<xs:complexType name="GetPictureManagerOptionsResponseType">
		<xs:annotation>
			<xs:documentation>
	      Returns a list of Picture Manager options and allowed values.
	    </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Subscription" type="ns:PictureManagerSubscriptionType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
					     A type of Picture Manager subscription, with a subscription level, fee, and allowed storage size.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPictureManagerOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PictureType" type="ns:PictureManagerPictureDisplayType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
					     A global definition for displaying pictures, with a maximum size.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPictureManagerOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPopularKeywords -->
	<xs:element name="GetPopularKeywordsRequest" type="ns:GetPopularKeywordsRequestType"/>
	<xs:complexType name="GetPopularKeywordsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the words more frequently used by eBay users when
				searching for listings. These keywords are generated weekly by
				eBay. Thus, calls retrieve static data. GetPopularKeywords is not
				available for the following SiteIDs 71 ,201, 207, 211, 212, 216,
				218.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the words more frequently used by eBay users
						when searching for listings.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A category ID for which you want keywords returned.
								When IncludeChildCategories is true, one and only one
								CategoryID is allowed. Otherwise, up
								to 100 CategoryIds are allowed.
								To retrieve the keywords for root category, set one of
								the CategoryIDs to -1 or submit no CategoryIDs at all.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeChildCategories" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, only one CategoryID can be specified, and keywords
								are returned for that category and its subcategories.
								If false, keywords are returned only for the categories
								identified by CategoryID. Default is false.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MaxKeywordsRetrieved" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The maximum number of keywords to be retrieved per category
								for this call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
								<Min>1</Min>
								<Max>1000</Max>
								<Default>20</Default>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Details about how many categories to return per
								page and which page to view.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPopularKeywords -->
	<xs:element name="GetPopularKeywordsResponse" type="ns:GetPopularKeywordsResponseType"/>
	<xs:complexType name="GetPopularKeywordsResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the keyword data for the requested categories. A category's data are contained in a CategoryArrayType object if there is no error (one or more CategoryType objects). Each CategoryType contains its ID, parent ID and keyword list.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
											Contains information regarding the pagination of data (if pagination is used),
											including total number of pages and total number of entries.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryArray" type="ns:CategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Organization of keywords by category. For each
								category, its ID and its parent's ID and keywords
								are listed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMore" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether there are more categories beyond the 
								subset returned in the last 
								call to GetPopularKeywords. Returned only when 
								IncludeChildCategories is true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPopularKeywords</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductFamilyMembers -->
	<xs:element name="GetProductFamilyMembersRequest" type="ns:GetProductFamilyMembersRequestType"/>
	<xs:complexType name="GetProductFamilyMembersRequestType">
		<xs:annotation>
			<xs:documentation>
GetProductFamilyMembers is intended to be used combination with GetProductSearchResults.
If a search result returned from GetProductSearchResults does not return all
product versions in a family, and if the user wants to see more versions (editions)
of the product, you can use GetProductFamilyMembers to retrieve all versions of the product.
That is, if GetProductSearchResultsonly returns the product family header (ParentProduct),
use this call to zoom in on a particular family of product versions.
(This situation usually occurs when you call GetProductSearchResults and more more
matches are found than the MaxChildrenPerFamily value you specified.)&lt;br&gt;
&lt;br&gt;
The structure of tGetProductFamilyMembers is similar to that of GetProductSearchResults.
Instead of passing in a query, you pass in a product ID. This product ID is used to
find all the members of the product family that the specified product is a member of.
The results are compatible with the results from GetProductSearchResults,
so similar application logic can be used to handle both requests and responses.
This call supports batch requests. This means you can retrieve products in
multiple families by using a single request. To perform a batch request,
pass an array of ProductSearch objects in the call.&lt;br&gt;
&lt;br&gt;
For each ProductSearch object, GetProductFamilyMembers returns a list of all the
products in the specified product family. Each product is represented as a list of
attributes (Item Specifics) plus other identifying information, such as a product ID
and a stock photo.&lt;br&gt;
&lt;br&gt;
Once the user selects a product from the results, pass its ID in a GetProductSellingPages
request to retrieve more detailed information about the product, including a set of
optional Item Specifics that the seller can use in addition to the
pre-filled Item Specifics (see GetProductSellingPages). &lt;br&gt;
&lt;br&gt;
To use this data in a listing, pass the product ID and the optional Item Specifics
in the seller's listing request (AddItem).
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						If a search result returned from GetProductSearchResults
						does not return all product versions in a family, and if the user wants to
						see more versions (editions) of the product, you can use
						GetProductFamilyMembers to retrieve all versions of the product.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ProductSearch" type="ns:ProductSearchType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Specifies the ID of a product in the family to be retrieved,
								along with pagination and sorting instructions.
								ProductSearch is a required input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFamilyMembers</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductFamilyMembers -->
	<xs:element name="GetProductFamilyMembersResponse" type="ns:GetProductFamilyMembersResponseType"/>
	<xs:complexType name="GetProductFamilyMembersResponseType">
		<xs:annotation>
			<xs:documentation>
				GetProductFamilyMembers performs a product search and returns results comprising
				all the children in the product family identified by a product ID that was 
				specified in the request. Use this call when more matches are found than the 
				max amount specified per family in a call to GetProductSearchResults.
				This call supports batch requests. This means you can retrieve products in 
				multiple families by using a single request.
				The results are compatible with the results from GetProductSearchResults,  
				so similar application logic can be used to handle both requests and responses.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="DataElementSets" type="ns:DataElementSetType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Container for one or more DataElement fields containing supplemental helpful data. 
								A DataElement field is an HTML snippet that specifies hints for the user, help links, 
								help graphics, and other supplemental information that varies per characteristics set. 
								Usage of this information is optional and may require developers to inspect the information 
								to determine how it can be applied in an application. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFamilyMembers</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductSearchResult" type="ns:ProductSearchResultType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Contains the attributes and summary product details for all products that match  
								the product ID (or IDs) passed in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFamilyMembers</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductFinder -->
	<xs:element name="GetProductFinderRequest" type="ns:GetProductFinderRequestType"/>
	<xs:complexType name="GetProductFinderRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves data that you use to construct valid "product finder" queries
				(queries against multiple attributes) against catalog products or listed items.
				The attributes describe search criteria (e.g., Manufacturer), as appropriate for the category.
				Use the results in combination with GetProductFinderXSL to render the Product Finder
				in a graphical user interface.
				GetProductFinder does not conduct the actual product or listing search.
				It only returns data about what you can search on. Use the data as input to
				GetProductSearchResults to conduct the actual search for product information
				or as input to GetSearchResults to conduct the search for listed items.
				To retrieve single-attribute search criteria (querying against a single attribute, like UPC),
				use GetProductSearchPage instead (only applicable for catalog searches).
				See the Developer's Guide for an overview of Pre-filled Item Information and details about
				searching for catalog products and for information about searching for listed items.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves data that you use to construct valid "product
						finder" queries (queries against multiple attributes) against
						catalog products or listed items.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A version of the product finder attribute definitions for the site.
								Typically, an application passes the version value that was returned the last
								time the application executed this call.
								Filter that causes the call to return only the Product Finders
								for which the attribute meta-data has changed since the specified version.
								The latest version value is not necessarily greater than the previous
								value that was returned. Therefore, when comparing versions, only
								compare whether the value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinder</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductFinderID" type="xs:int" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A number that uniequely identifies a product finder. To determine the
								product finder IDs for a category, call GetCategory2CS.
								Multiple categories can be mapped to the same product finder ID.
								You can pass zero or multiple IDs in the request. When IDs are specified, the call
								only returns product finder meta-data for the specified product finders.
								When no IDs are specified, the call returns all the current product finder
								meta-data available on the site.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinder</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductFinder -->
	<xs:element name="GetProductFinderResponse" type="ns:GetProductFinderResponseType"/>
	<xs:complexType name="GetProductFinderResponseType">
		<xs:annotation>
			<xs:documentation>
      For a category that supports product finders, GetProductFinder returns an XML string
      that decribes the attributes a seller can use to form a query when searching for
      Pre-filled Item Information, or attributes that can be used to search for listed items.
      Specifically, it retrieves data that you use to construct valid "product finder" queries
      (queries against multiple attributes).
      Use the results in combination with GetProductFinderXSL to render the Product Finder
      in a graphical user interface.
      See the Developer's Guide for an overview of Pre-filled Item Information and details about
      searching for catalog products and for information about searching for listed items.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Current version of the product search page data for the site.
                  This value changes each time changes are made to the search page data.
                  The current version value is not necessarily greater than the previous
                  value. Therefore, when comparing versions, only compare whether the
                  value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinder</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductFinderData" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							A string containing a list of search attributes that can be used in a
							"Product Finder" style query, along with related meta-data.
							The meta-data specifies possible values of each attribute, the
							logic for presenting attributes to a user, and rules for validating the
							user's selections. For backward compatibility, this data is in
							the same XML format that was used in the Legacy XML API so that you can
							apply the same Product Finder XSL stylesheet to it. That is, individual
							elements are not described using the new eBay XML schema format.
							For information about each element in the ProductFinderData string,
							see the product finder model documentation in the eBay Web Services guide (see links below).&lt;br&gt;
							&lt;br&gt;
							Because this is returned as a string, the XML markup is escaped with
							character entity references (e.g., &amp;amp;lt;eBay&amp;amp;gt;&amp;amp;lt;ProductFinders&amp;amp;gt;...).
							See the appendices in the eBay Web Services guide for general information about
							string data types.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinder</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnAll</DetailLevels>
								</CallInfo>
								<SeeLink>
									<Title>The Product Finder Meta-Data Model</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AttrPFModel</URL>
								</SeeLink>
								<SeeLink>
									<Title>Data Types</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=DataTypes</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductFinderXSL -->
	<xs:element name="GetProductFinderXSLRequest" type="ns:GetProductFinderXSLRequestType"/>
	<xs:complexType name="GetProductFinderXSLRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the Product Finder XSL stylesheet. Apply the stylesheet
				to the XML returned from a call to GetProductFinder to render a
				form that lets a user form a multi-attribute query against eBay
				catalog data. See the Developer's Guide for an overview of Pre-
				filled Item Information and information on searching for catalog
				products.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the Product Finder XSL stylesheet for use with
						the XML returned from GetProductFinder.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="FileName" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The name of the XSL file to retrieve. If not specified, the call
								returns the latest versions of all available XSL files.
								FileName is an optional input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinderXSL</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FileVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The desired version of the XSL file. Required if FileName is specified.
								IIf not specified, the call returns the latest versions of all
								available XSL files that could be returned by the call.
								This is not a filter for retrieving changes to the XSL files.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinderXSL</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductFinderXSL -->
	<xs:element name="GetProductFinderXSLResponse" type="ns:GetProductFinderXSLResponseType"/>
	<xs:complexType name="GetProductFinderXSLResponseType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the Product Finder XSL stylesheet. Apply the stylesheet to the 
				XML returned from a call to GetProductFinder to
				render a form that lets a user form a multi-attribute query against 
				eBay catalog data.
				See the Developer's Guide for an overview of Pre-filled Item Information
				and information on searching for catalog products.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="XSLFile" type="ns:XSLFileType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Child elements specify data related to one XSL file. See XSLFileType.
								Multiple XSLFile objects can be returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductFinderXSL</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductSearchPage -->
	<xs:element name="GetProductSearchPageRequest" type="ns:GetProductSearchPageRequestType"/>
	<xs:complexType name="GetProductSearchPageRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the attributes a seller can use to form a query when
				searching for Pre-filled Item Information to use in a listing for
				a category that is catalog-enabled. This call is applicable for
				use cases related to listing items with Pre-filled Item
				Information. Specifically, it retrieves data
				that you use to construct valid "single-attribute" queries. The
				attributes describe search criteria (e.g., Author) and sorting
				criteria (e.g., Publication Year), as appropriate for the
				category. GetProductSearchPage does not conduct the actual
				product search. It only returns data about what you can search
				on. Use the data as input to GetProductSearchResults to conduct
				the actual search for product information. To retrieve Product
				Finder search criteria (querying against multiple attributes),
				use GetProductFinder instead. See the eBay Web Services guide for
				an overview of Pre-filled Item Information and details about
				searching for catalog products.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the attributes a seller can use to form a query when
						searching for Pre-filled Item Information to use in a listing for
						a category that is catalog-enabled.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A version of the search page definitions for the site. Typically, an
								application passes the version value that was returned the last time the
								application executed this call. Filter that causes the call to return only
								the search pages for which the attribute meta-data has changed since the
								specified version. The latest version value is not necessarily greater
								than the previous value that was returned. Therefore, when comparing
								versions, only compare whether the value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchPage</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AttributeSetID" type="xs:int" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A characteristic set ID that is associated with a
								catalog-enabled category that supports product search pages.
								You can pass an array of these IDs in the request.
								Each characteristic set corresponds to a level in the
								eBay category hierarchy at which all items share common characteristics.
								Multiple categories can be mapped to the same characteristic set.
								Each ID is used as a filter to limit the response content to fewer
								characteristic sets. When IDs are specified, the call only returns
								search page data for the corresponding characteristic sets.
								When no IDs are specified, the call returns all the current
								search page data in the system.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchPage</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductSearchPage -->
	<xs:element name="GetProductSearchPageResponse" type="ns:GetProductSearchPageResponseType"/>
	<xs:complexType name="GetProductSearchPageResponseType">
		<xs:annotation>
			<xs:documentation>
      For a category that is catalog-enabled, GetProductSearchPage retrieves the attributes 
      a seller can use to form a query when searching for Pre-filled Item Information. 
      See the Developer's Guide for an overview of Pre-filled Item Information and details about 
      searching for catalog products.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="AttributeSystemVersion" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Current version of the product search page data for the site.
								This value changes each time changes are made to the search page data.
								The current version value is not necessarily greater than the previous
								value. Therefore, when comparing versions, only compare whether the 
								value has changed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchPage</CallName>
									<DetailLevels>none, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductSearchPage" type="ns:ProductSearchPageType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A list of catalog search criteria and sort keys associated with a catalog-enabled category, 
								plus supplemental information to help the seller understand how to make selections.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchPage</CallName>
									<DetailLevels>ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductSearchResults -->
	<xs:element name="GetProductSearchResultsRequest" type="ns:GetProductSearchResultsRequestType"/>
	<xs:complexType name="GetProductSearchResultsRequestType">
		<xs:annotation>
			<xs:documentation>
Searches for Pre-filled Item Information within one or more
characteristic sets. This kind of search is only applicable in the context of the Sell Your Item use case.
Use the response to present the seller with a list of products found in a catalog.
(For buy-side searches, use GetSearchResults.)&lt;br&gt;
&lt;br&gt;
See the Attributes and Catalogs section of the eBay Web Services guide for background information
and terminology definitions, as well as information about how to use this call in the Sell Your Item flow.&lt;br&gt;
&lt;br&gt;
You can use this call to search for different products at the same time.
That is, this call can perform batch searches.&lt;br&gt;
&lt;br&gt;
Given an array of ProductSearch properties that are configured with a list of search attributes or keywords
(and other information), GetProductSearchResults searches an eBay catalog for products that match each query.
Some queries can be configured to also specify a sort order for the results.&lt;br&gt;
&lt;br&gt;
To configure a ProductSearch object to search by attributes, you need a valid combination of search attributes.
If you want to use a sort order other than the default order, you also need a valid sort attribute.
We offer two calls that return product search and sort attributes.
Use GetCategory2CS to determine which one of these calls you can use for a given category.
At least one approach is offered for each catalog-enabled category, and some cases, both are offered.&lt;br&gt;
&lt;br&gt;
&lt;b&gt;GetProductSearchPage&lt;/b&gt;: Use this call when you want to configure a simple query that consists of a
single search attribute (with a value). This retrieves a single product or a very short list of search results
to choose from. Some products are fairly easy to find based on a single attribute. For example, in
Consumer Electronics categories (Digital Cameras, Cell Phones, and PDAs), you can specify a unique (or nearly unique) identifier, like a part number. In Media categories (Books, DVDs &amp; Movies, Music, and Video Games), you can specify a descriptive name, like a title. &lt;br&gt;
&lt;br&gt;
&lt;b&gt;GetProductFinder&lt;/b&gt;: Use this call when you want to configure a complex query. In the Sell Your Item flow, this is a complex query against the eBay product catalog. Currently, this type of search is available in Consumer Electronics categories only. In this type of search, you specify values for multiple attributes, like Brand and Resolution (i.e., number of megapixels). This retrieves a list of matching products.
This approach is useful when the user does not know the part number, or a product does not have a single, distinguishing feature that is easy to search on. For example, searching for a digital camera based solely on the brand would likely yield far too many results to be useful. Searching on the brand, product line, and resolution will retrieve a much shorter list of results. &lt;br&gt;
&lt;br&gt;
Alternatively, you can search on a particular keyword that appears in a product's title or Item Specifics.
For this, you use GetProductSearchResults and and pass in one or more text strings (with optional wildcards)
in ProductSearch.QueryKeywords. &lt;br&gt;
&lt;br&gt;
When you use a keyword query, the search criteria are not restricted to the results of a product search page or
product finder, so the criteria are not tied to a particular characteristic set. This means you can search across
multiple characteristic sets using the same query. This is useful when the user wants to broaden their search
across multiple categories. For example, a seller who sells Jazz books, Jazz CDs, and Jazz movies may want to
search for "Bird" across multiple categories. Specify the characteristic set IDs of interest by using CharacteristicSetIDs. &lt;br&gt;
&lt;br&gt;
GetProductSearchResults returns a list of matching products, if any. Each product is represented as a list of
attributes (Item Specifics) plus other identifying information, such as a product ID and a stock photo. &lt;br&gt;
&lt;br&gt;
Once the user selects a product from the list (this may require a call to GetProductFamilyMembers to retrieve
additional products to choose from), pass its ID in a GetProductSellingPages request to retrieve more
detailed information about each product, including a set of optional Item Specifics that the seller
can use in addition to the pre-filled Item Specifics (see GetProductSellingPages). &lt;br&gt;
&lt;br&gt;
To use this data in a listing, pass the product ID and the optional Item Specifics in the seller's listing request (AddItem).
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Searches for Pre-filled Item Information within one or more
						characteristic sets.
						Use the response from GetProductSearchPage or GetProductFinder to determine
						the attributes that can be used as criteria for the search.
						After a user selects a product by its ID, use the ID as input to GetProductSellingPages.
						This call also supports batch requests (i.e., searching for several products in the same call). 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ProductSearch" type="ns:ProductSearchType"  minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
                  Specifies the keywords or attributes that make up the product query,
                  with pagination instructions.
								ProductSearch is a required input. To search for multiple different products at the same time
								(i.e., to perform a batch search), pass in multiple ProductSearch properties.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchResults</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductSearchResults -->
	<xs:element name="GetProductSearchResultsResponse" type="ns:GetProductSearchResultsResponseType"/>
	<xs:complexType name="GetProductSearchResultsResponseType">
		<xs:annotation>
			<xs:documentation>
      GetProductSearchResults performs a product search and collects the results. 
      Result attributes for each product/product family are grouped and identified 
      with a product ID. If more matches are found than the max amount specified per family, 
      only the product family information is returned. In this case, call GetProductFamilyMembers 
      to retrieve more products within the same family.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="DataElementSets" type="ns:DataElementSetType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
                  Container for one or more DataElement fields containing supplemental helpful data. 
                  A DataElement field is an HTML snippet that specifies hints for the user, help links, 
								help graphics, and other supplemental information that varies per characteristic set.
								Usage of this information is optional and may require you to inspect the information
                  to determine how it can be applied in an application. 
                  Also returned with warnings when no matches are found.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductSearchResult" type="ns:ProductSearchResultType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Contains the attributes and product details that match the attributes or query keywords
                  passed in the request. Always returned when product search results are found.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductSellingPages -->
	<xs:element name="GetProductSellingPagesRequest" type="ns:GetProductSellingPagesRequestType"/>
	<xs:complexType name="GetProductSellingPagesRequestType">
		<xs:annotation>
			<xs:documentation>
      	Retrieves information that describes how to present catalog
				product information to a seller. Use this information to present
				users with the equivalent of the Item Specifics portion of the
				eBay Title and Description pages and to validate user-specified
				values for eBay attributes on the client before including them in
				an AddItem call or related calls. The data contains a list of all
				the attributes that are applicable for one or more requested
				products, along with related meta-data. The meta-data specifies
				the pre-filled values of each attribute, the possible values of
				attributes that are not pre-filled, the logic for presenting the
				attributes to a user, and rules for validating the user's
				selections. Use the results in combination with GetAttributesXSL
				to render the Item Specifics in a graphical user interface. See
				the eBay Web Services Guide for an overview of Pre-filled Item
				Information, details about searching for catalog products, and
				information about the ProductSellingPages content model.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves information that describes how to present catalog
						product information to a seller.
						Use this data when listing an item with Pre-filled
						Item Information. 
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="UseCase" type="ns:ProductUseCaseCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the context in which the call is being executed, which will imply
								certain validation rules. Use this property to make sure you retrieve the
								appropriate version of product information and attribute meta-data
								when you are listing, revising, or relisting an item with Pre-filled Item Information.
								Valid values:&lt;br&gt;
								&lt;b&gt;SYI&lt;/b&gt; = Sell Your Item. Use before adding an item. Causes the response to include the
								latest product ID in the system (given an ID specified in the Products element)
								and the corresponding characteristic meta-data.&lt;br&gt;
								&lt;b&gt;RYI&lt;/b&gt; = Revise Your Item. Use this before revising an item. Causes the response to return
								the product ID, attribute data, and other data associated with the version of the product
								that you pass in the Products element. This is useful in case the product ID or associated data
								has changed in the system since the item was originally listed. When revising
								an item, this helps you make changes that are consistent with the original listing.&lt;br&gt;
								&lt;b&gt;RELIST&lt;/b&gt; = Use this before relisting an item. Causes the response to include the
								latest product ID in the system (given an ID specified in the Products element)
								and the corresponding characteristic meta-data. (Same as SYI).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSellingPages</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Product" type="ns:ProductType"  minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A catalog product identifies a prototype description
								of a well-known type of item, such as a popular book.
								As this call supports batch requests, you can pass in an array of products
								to retrieve data for several products at the same time.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSellingPages</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetProductSellingPages -->
	<xs:element name="GetProductSellingPagesResponse" type="ns:GetProductSellingPagesResponseType"/>
	<xs:complexType name="GetProductSellingPagesResponseType">
		<xs:annotation>
			<xs:documentation>
      Retrieves an XML string that describes how to present catalog product information to a seller.
      Use this information to present users with the equivalent of the Item Specifics portion
      of the eBay Title and Description pages and to validate user-specified values for
      eBay attributes on the client before including them in an AddItem call or related calls. 
      Use the results in combination with GetAttributesXSL to render the Item Specifics
      in a graphical user interface.
      See the Developer's Guide for an overview of Pre-filled Item Information and details about 
      searching for catalog products.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ProductSellingPagesData" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							A string containing a list of all the attributes that are applicable 
							to the products specified in the request, along with related meta-data. 
							The meta-data specifies the pre-filled values of each attribute, the 
							possible values of attributes that are not pre-filled, the logic for presenting 
							the attributes to a user, and rules for validating the user's selections.
							&lt;br&gt;&lt;br&gt; 
							For backward compatibility, this data is in
							the same XML format that was used in the Legacy XML API so that you can 
							apply the same Item Specifics XSL stylesheet to it. That is, individual 
							elements are not described using the unified schema format.
							&lt;br&gt;&lt;br&gt;
							The data is based on the GetAttributesCS response (AttributeData), with 
							additional information that is specific to catalog products.
							Product and attribute information is nested within a set of Product tags. 
							The product-specific data is merged into the attribute data so that the same 
							XSL stylesheet used to render the results of GetAttributeCS can be used to render 
							catalog product data. See GetAttributesXSL.
							&lt;br&gt;&lt;br&gt;
							See the Attribute Meta-Data Model section of the eBay Web Services guide 
							for information about each element in the ProductSellingPagesData string.
							&lt;br&gt;&lt;br&gt;
							Because the content is returned as a string, the XML markup elements are escaped with 
							character entity references (e.g.,&amp;amp;lt;eBay&amp;amp;gt;&amp;amp;lt;Attributes&amp;amp;gt;...). 
							See the appendices in the eBay Web Services guide for general information about 
							string data types.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetProductSellingPages</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPromotionRules -->
	<xs:element name="GetPromotionRulesRequest" type="ns:GetPromotionRulesRequestType"/>
	<xs:complexType name="GetPromotionRulesRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests a list of the cross-promotion rules associated with
				a specific referring item or store category.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests a list of the cross-promotion rules associated
						with a specific referring item or store category.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique ID of the referring item for which
								you want promotion rules. Specify a value for
								either ItemID or StoreCategoryID, never both.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetPromotionRules</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StoreCategoryID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique ID of the store category for which you
								want promotion rules. Specify a value for
								either ItemID or StoreCategoryID, never both.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPromotionRules</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PromotionMethod" type="ns:PromotionMethodCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The type of promotion rules to retrieve, either UpSell
								or CrossSell.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPromotionRules</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetPromotionRules -->
	<xs:element name="GetPromotionRulesResponse" type="ns:GetPromotionRulesResponseType"/>
	<xs:complexType name="GetPromotionRulesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns a list of promotion rules associated with a specific
				item or store category. 
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PromotionRuleArray" type="ns:PromotionRuleArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation> 
								An array of upsell or cross-sell promotion rules
								associated with the item or category specified in
								the request. All rules in the array are either
								upsell or cross-sell, according to the value of
								PromotionMethod specified in GetPromotionRulesRequest.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetPromotionRules</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetRecommendations -->
	<xs:element name="GetRecommendationsRequest" type="ns:GetRecommendationsRequestType"/>
	<xs:complexType name="GetRecommendationsRequestType">
		<xs:annotation>
			<xs:documentation>
				(Use GetItemRecommendations instead of GetRecommendations.
				GetItemRecommendations supports
				all the same features as GetRecommendations and adds support for batch requests.)
				Invokes one or more specified recommendation engines. These engines can examine potential item data
				that a seller has specified and return recommended changes or opportunities for improvement.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Deprecated soon.
						Please use GetItemRecommendations instead.
						Invokes one or more specified recommendation engines.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ListingFlow" type="ns:ListingFlowCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The listing flow for which the seller is seeking Listing Analyzer recommendations.
								Not applicable to results from other recommendation engines.
								The default flow is AddItem.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains fields that describe the item for which you are seeking recommendations.
								If the Listing Analyzer recommendation engine is run, the applicable fields are
								the same as the fields for AddItem, ReviseItem, or RelistItem
								requests, as determined by the value specified in ListingFlow.
								The item ID (Item.ItemID) is required when the ListingFlow is ReviseItem or RelistItem.
								All other item fields are optional, even if listed as required for other calls.
								However, as some tips are dependent on the properties of the item, and as some properties
								have dependencies on other properties, we strongly recommend that you include all the item properties
								that will be included in the AddItem, ReviseItem, or RelistItem request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An ISBN value, UPC value, or eBay catalog product ID. Identifies
								Pre-filled Item Information that the seller wants to include in the listing.
								Only applicable for certain categories and only applicable when the value of
								ListingFlow is AddItem. Not applicable when the recommendation engine is ProductPricing.
								See the Developer's Guide for information on the categories
								that currently support usage of this field.
								Either ExternalProductID or Item.ProductListingDetails can be specified
								in the request, but not both.
								If the primary and secondary category are both catalog-enabled,
								this ID must be for a product associated with the primary category.
								If only one category is catalog-enabled, this ID must be for a product
								that is associated with the catalog-enabled category.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModifiedFields" type="ns:ModifiedFieldType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Applicable when the ListingFlow is ReviseItem or RelistItem.
								Array of item properties that are being changed.
								See the Developer's Guide for rules on adding, modifying, and removing
								values when revising or relisting items.
								In release 439 and later, ModifiedFields is no longer required to revise
								field values, but it is still supported for backward compatibility.
								See the Developer's Guide for rules on adding, modifying, and removing
								values when revising or relisting items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RecommendationEngine" type="ns:RecommendationEngineCodeType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								An array of recommendation engines. If no engines are specified, all available
								recommendation engines will run. Certain input fields (such as Item.PrimaryCategory.CategoryID)
								are required in order to run all engines with no errors.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Query" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the search string, consisting of one or
								more words to search for in the listing title.
								The words "and" and "or" are treated like any other
								word.
								Required when the Suggested Attributes engine is used.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>350 (characters)</MaxLength>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetRecommendations -->
	<xs:element name="GetRecommendationsResponse" type="ns:GetRecommendationsResponseType"/>
	<xs:complexType name="GetRecommendationsResponseType">
		<xs:annotation>
			<xs:documentation>
Please use GetItemRecommendations instead of GetRecommendations. GetItemRecommendations supports 
all the same features as GetRecommendations and adds support for batch requests.
GetRecommendations returns recommended changes or opportunities for improvement 
related to listing data that was passed in the request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ListingAnalyzerRecommendations" type="ns:ListingAnalyzerRecommendationsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains tips returned from the Listing Analyzer recommendation engine, 
								if this engine was specified in the request (or if no engine was specified).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SIFFTASRecommendations" type="ns:SIFFTASRecommendationsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Reserved for future use.
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="PricingRecommendations" type="ns:PricingRecommendationsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains pricing data returned from the Product Pricing engine, 
								if this engine was specified in the request (or if no engine was specified).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AttributeRecommendations" type="ns:AttributeRecommendationsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains attribute suggestions returned from the Suggested Attributes engine, 
								if this engine was specified in the request.
								The results include suggested attributes and values based on the primary category 
								and a string you specify in the Query field. Suggestions may only be returned when the 
								Suggested Attributes engine is specified alone. If you request recommendations by using 
								multiple engines, suggested attribute data might not be returned. If attributes are returned 
								with multiple values, the values are returned in order of rank (i.e., the value that best meets 
								eBay's recommendation criteria is returned first). 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductRecommendations" type="ns:ProductRecommendationsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains zero or more product titles and IDs returned from the Suggested Attributes engine, 
								if this engine was specified in the request (or if no engine was specified).
								If applicable, use one of the suggested product IDs to list the item with Pre-filled Item Information. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRecommendations</CallName>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetReturnURL -->
	<xs:element name="GetReturnURLRequest" type="ns:GetReturnURLRequestType"/>
	<xs:complexType name="GetReturnURLRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns all of your application's authentication and authorization
				preferences and related data, such as the URLs that eBay should
				redirect users to after they complete the authentication and
				authorization process. This call must be authenticated using the
				application's username and password (not an authentication token).
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns all of your application's authentication and authorization
						preferences and related data.
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Authentication &amp; Authorization</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetReturnURL -->
	<xs:element name="GetReturnURLResponse" type="ns:GetReturnURLResponseType"/>
	<xs:complexType name="GetReturnURLResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns all the authentication and authorization preferences and related data for
				the application.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ApplicationDisplayName" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Display name for the application. When your application
								redirects users to eBay to complete the authentication and
								authorization process, eBay displays this value to identify
								your application to the user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetReturnURL</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AuthenticationEntryArray" type="ns:AuthenticationEntryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
						    One or more sets of authentication preferences and other data that you
								have configured for your application (if any). Call SetReturnURL to
								configure this data.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetReturnURL</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
								<SeeLink>
									<Title>Authentication &amp; Authorization</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetRuName -->
	<xs:element name="GetRuNameRequest" type="ns:GetRuNameRequestType"/>
	<xs:complexType name="GetRuNameRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns a globally unique runame (unique identifier for an authentication data
				entry). This call must be authenticated using the application's username and
				password, rather than a token.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns a globally unique runame (unique identifier for an authentication data entry).
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Authentication &amp; Authorization</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ClientUseCase" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Optional value that is appended to the generated runame.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRuName</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetRuName -->
	<xs:element name="GetRuNameResponse" type="ns:GetRuNameResponseType"/>
	<xs:complexType name="GetRuNameResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the generated runame (unique identifier for an authentication data entry).
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="RuName" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The generated globally unique runame.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetRuName</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSearchResults -->
	<xs:element name="GetSearchResultsRequest" type="ns:GetSearchResultsRequestType"/>
	<xs:complexType name="GetSearchResultsRequestType">
		<xs:annotation>
			<xs:documentation>
				Conducts a search for items on eBay based on a user-specified set of one or more
				keywords. Returns those item listings where the keywords appear in the
				title, subtitle, and (optionally) the description. The request includes
				various kinds of fields that control the output. Some fields (e.g.,
				Query) are primary search criteria that let you specify data to match in
				listings. For example, you can search for all listings that include the
				word "Toy" in the title. Some fields (e.g., ItemTypeFilter) are
				secondary search criteria that let you further refine data to match in
				listings. For example, you can search for all toys that are listed as
				auctions. In general, the effect of secondary search fields is
				cumulative (using "AND" logic) unless otherwise specified. Some fields
				(e.g., TotalOnly) control what is actually returned in the result set.
				For example, you can search for all toys that are listed as Chinese
				auctions, but just retrieve the total count (not the listings
				themselves). Some fields (e.g., IncludeCondition) affect the data to
				retrieve for each listing in the result set. For example, for each toy
				returned in the result, you can also choose to see the toy's new or used
				condition. Some fields (e.g., Order) control the way the listings are
				organized in the response. For example, you can retrieve all the toy
				listings in chronological order, with the newest one first. Use the
				DetailLevel ItemReturnCategories to return the primary category and, if
				applicable, the secondary category. Use the DetailLevel
				ItemReturnAttributes (or ReturnAll) to return summary Item Specifics
				(only returned for categories that support summary Item Specifics in
				search results).&lt;br&gt;&lt;br&gt;Not applicable to eBay Express or Half.com.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves item listings based on keywords you specify. 
						The keywords can include wildcards. 
						The response is in the form of an array whose size and contents you specify,
						using a variety of input fields.  
						You can filter the item listings returned
						using such criteria as the listing category, location, whether the item is listed
						in an ebay Store, and listing type. You can include or exclude specified sellers.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="MotorsGermanySearchable" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the results based on each item's eligibility to appear on the
								mobile.de site. If false, excludes eligible items from search results. If
								true, queries for eligible items only. If not specified, the search
								results are not affected. Only applicable for items listed on the eBay
								Germany site (site ID 77) in subcategories of mobile.de search-enabled
								categories.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Query" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A query that specifies a search string. The search string consists of one or more
								keywords to search for in the listing title and/or description.
								The words "and" and "or" are treated like any other word. Only use "and",
								"or", or "the" if you are searching for listings containing these words.
								You can use AND or OR logic by including certain modifiers.
								Wildcards (e.g., *) are also supported. Be careful when using spaces before
								or after modifiers and wildcards (+, -, or *). See the
								eBay Web Services Guide	for a list of valid modifiers and examples.
								Query is not applicable in combination with ExternalProductID or ProductID.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>350 (characters)</MaxLength>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items listed in the specified
								category. You can use the ItemReturnCategories detail level. If you use
								the ItemReturnCategories detail level, the results include the primary
								category of retrieved items and, if applicable, the secondary category.
								Defaults to all categories if no category ID is specified. If
								the specified category ID does not match an existing category for the
								site, an invalid-category error message is returned.
								You must pass ProductID, Query, ExternalProductID, or CategoryID in the request.
								CategoryID can be used in combination with Query. It is not
								allowed with ExternalProductID, ProductID, or when SearchRequest is used.
								If you pass CategoryID without Query, it must specify a leaf category ID.
								That is, it cannot be a meta-category ID (e.g., 267 for "Books").
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchFlags" type="ns:SearchFlagsCodeType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Secondary search criterion that checks item descriptions for keywords that
								match the query, limits the search results to only charity items, limits
								the result set to those items with PayPal as a payment method, and/or
								provides other criteria to refine the search. Not allowed with
								UserIdFilter (IncludeSellers or ExcludeSellers).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PriceRangeFilter" type="ns:PriceRangeFilterType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items where the price is within the
								specified range. The PriceRangeFilterType includes a minimum and a maximum
								price.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProximitySearch" type="ns:ProximitySearchType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items whose location is within a
								specified distance of a postal code. The ProximitySearchType includes
								a maximum distance and a postal code.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemTypeFilter" type="ns:ItemTypeFilterCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Filters items based on the ListingType set for the items. 
								If you search for Store Inventory items, you should use values in ItemTypeFilter
								instead of StoresFixedPrice.								
								If ItemTypeFilter is not specified (or if the AllItemTypes value of ItemTypeFilter is specified), all listing types can be returned unless another relevant filter is specified.
								You cannot use GetSearchResults to search eBay Express.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
									<Default>AllItems</Default>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchType" type="ns:SearchTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the listings in the result set based on whether they are in the
								Gallery. The choices are items in the Gallery or Gallery and non-Gallery
								items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserIdFilter" type="ns:UserIdFilterType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the the result set to just those items listed by one or more
								specified sellers or those items not listed by the one or more specified
								sellers.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchLocationFilter" type="ns:SearchLocationFilterType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items that meet location criteria:
								listed in a specified eBay site, location where the seller has the item,
								location from which the user is searching, and/or items listed with a
								specified currency. You cannot use GetSearchResults to search eBay Express.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StoreSearchFilter" type="ns:SearchStoreFilterType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those items that meet criteria related to
								eBay Stores sellers and eBay Stores. Use this to retrieve items listed in a particular
								seller's eBay Store or in all store sellers' eBay Stores.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Order" type="ns:SearchSortOrderCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the order in which listings are returned in a result set. Listings may be
								sorted by end time, start time, and in other ways listed in the
								SearchSortOrderCodeType. Controls the way the listings are organized in the response
								(not the details to return for each listing).
								For most sites, the default sort order is by items ending soonest.
								Store Inventory listings are usually returned after other listing types, regardless of the sort order.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Controls the pagination of the result set. Child elements specify the maximum number of
								item listings to return per call and which page of data to return. Controls the way the
								listings are organized in the response (not the details to return for each listing).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchRequest" type="ns:SearchRequestType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A query consisting of a set of attributes (Item Specifics). Use this kind of
								query to search against the Item Specifics in listings (e.g., to search for
								a particular shoe size). If the query includes multiple attributes, the search engine will apply "AND"
								logic to the query and narrow the results. Use GetProductFinder to determine the list of
								valid attributes and how many are permitted for the specified characteristic set.
								Retrieves items along with any buying guide details that are associated with
								the specified product finder.
								Applicable in combination with the Query argument. Cannot be used in
								combination with ProductID or ExternalProductID.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An exclusive query to retrieve items that were listed with the specified eBay catalog
								product. You must pass ProductID, Query, ExternalProductID, or CategoryID in the
								request. If you use ProductID, do not use Query, ExternalProductID, or CategoryID.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An exclusive query to only retrieve items that were listed with the specified ISBN or UPC.
								Only applicable for items that were listed with Pre-filled Item Information
								in media categories (Books, Music, DVDs and Movies, and Video Games).
								You must pass ProductID, Query, ExternalProductID, or CategoryID in the request.
								If you use ExternalProductID, do not use Query, ProductID, or CategoryID.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Categories" type="ns:RequestCategoriesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Retrieves statistical information about categories that contain items that match the query.
                  Can also cause the result to include information about buying guides that are
                  associated with the matching categories.
                  Does not control the set of listings to return or the details to return for each listing.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TotalOnly" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Retrieves the total quantity of matching items, without
								returning the item data. See PaginationResult.TotalNumberOfEntries
								in the response. If TotalOnly and Categories.CategoriesOnly are both specified
								in the request and their values are inconsistent with each other,
								TotalOnly overrides Categories.CategoriesOnly.
								That is, if TotalOnly is true and Categories.CategoriesOnly is false,
								the results include matching categories but no item data or buying guides.
								If TotalOnly is false and Categories.CategoriesOnly is true, the results
								include matching categories, item data, and buying guides.
								If TotalOnly is not specified, it has no logical effect.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the results to items ending within a time range.
								EndTimeFrom specifies the beginning of the time range. Specify a time in the future.
								If you specify a time in the past, the current time is used. If specified,
								EndTimeTo must also be specified (with a value equal to or later than EndTimeFrom).
								Express the time in GMT. Cannot be used with the ModTimeFrom filter.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the results to items ending within a time range. EndTimeTo specifies
								the end of the time range. If specified, EndTimeFrom must also be specified
								(with a value equal to or earlier than EndTimeTo). Express the time in GMT.
								Cannot be used with the ModTimeFrom filter.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the results to active items whose status has changed
								since the specified time. Specify a time in the past.
								Time must be in GMT. Cannot be used with the EndTime filters.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeGetItFastItems" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								When passed with a value of true, limits the results to Get It Fast listings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StoresFixedPrice" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Ignored if Store-related values in ItemTypeFilterCodeType are used as input filters.
								Using values in ItemTypeFilterCodeType is preferable to using StoresFixedPrice.
								StoresFixedPrice controls whether or not to use the Store Inventory format as a filtering criterion.&lt;br&gt;&lt;br&gt;
								For US, Canada, and Motors:&lt;br&gt;
								The StoresFixedPrice input field does not currently work for these sites.
								For all other sites:&lt;br&gt;
								If true, the results only include Store Inventory listings (with no listings in other formats).&lt;br&gt;
								If false, the results only include listings in other formats (with no Store Inventory listings).&lt;br&gt;
								If omitted (the default), this filter is not applied at all,
								so all formats can be returned (depending on other criteria you pass in the request).
								In this case, Store Inventory listings appear after
								all other matching auction and basic fixed price listings. &lt;br&gt;&lt;br&gt;
								You can use this filter regardless of whether you are searching in eBay Stores.
								If you pass StoresFixedPrice in the same request with StoreSearchFilter or ItemTypeFilter,
								"AND" logic may be applied, and you might not get the desired results.
								For example, if you specify StoresFixedPrice=true and ItemTypeFilter=AuctionItemsOnly,
								the call will succeed but no listings will be returned (because no listings can use both
								auction and Store Inventory formats).
								This is why it is recommended that you use values in ItemTypeFilterCodeType instead of StoresFixedPrice.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
									<TagStatus>ObsoleteSoon</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentMethod" type="ns:PaymentMethodSearchCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the results to items that accept a specific payment method or methods.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="GranularityLevel" type="ns:GranularityLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Optional tag that currently accepts only one value for this call: Coarse. Other values
								return an error. Specify the value Coarse if you want only the following fields to be
								returned for items (if applicable to the result set): ItemID, Title, ViewItemURL,
								ListingType, StartTime, EndTime, BuyItNowPrice, CurrentPrice, ConvertedCurrentPrice,
								LocalizedCurrentPrice, Currency, ShippingType, DefaultShippingCost, Country,
								PostalCode, and any tags resulting from the detail level you specify. Controls the
								details to return for each listing (not the set of listings that match the query).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExpandSearch" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Expands search results when a small result set is returned. For example, on the US site
								(site ID 0), if a search would normally result in fewer than 10 items, then if you
								specify true for this tag, the search results are expanded. Specifically, the search
								returns items (if there are matches) in one or more of the following containers:
								InternationalExpansionArray (for items available from international sellers),
								FilterRemovedExpansionArray (items that would be returned if filters such as PriceRangeFilter are removed),
								and AllCategoriesExpansionArray (for items available if category filters are removed).
								Maximum number of items returned in each expansion container is 6 to 10.
              </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Lot" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Limits the results to only those listings for which Item.LotSize is 2 or greater.
              </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AdFormat" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							  Restricts listings to return only items that have the Ad Format feature.
								If true, the values of ItemTypeFilter, StoresFixedPrice, and
								StoreSearchFilter are ignored (if they are specified). That is, "AND"
								logic is not applied.
              </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Quantity" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							  Limits the results to listings that offer a certain number of items
								matching the query. If Lot is also specified, then Quantity is the number
								of lots multiplied by the number of objects in each lot. Use
								QuantityOperator to specify that you are seeking listings with quantities
								greater than, equal to, or less than Quantity.
              </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="QuantityOperator" type="ns:QuantityOperatorCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							  Limits the results to listings with quantities greater than, equal to, or
								less than Quantity. Controls the set of listings to return (not the
								details to return for each listing).
              </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerBusinessType" type="ns:SellerBusinessCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the results to those of a particular seller
								business type such as commercial or private.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>


					<xs:element name="DigitalDelivery" type="xs:boolean" minOccurs="0">
					<xs:annotation>
						<xs:documentation>
							If true, limits the results to digitally delivered good only. If false, this flag is
							ignored (i.e., false is the same as not specifying the flag at all).
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetSearchResults</CallName>
								<RequiredInput>No</RequiredInput>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
					</xs:element>
					<xs:element name="IncludeCondition" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								For eBay Germany only. If true, each item in the result set can also include the item condition attribute
								(e.g., New or Used) in the ItemSpecific property of the response.
								An item only includes a condition attribute in the response if the seller filled in
								the Item Condition in the Item Specifics section of the listing.
								(That is, the condition attribute is not returned if the seller only put the word
								"New" in the listing's title but did not specify the condition in the listing's Item Specifics.)
								Controls the details to return for each listing (not the set of listings that match the query).
								Note: This field does not control whether to retrieve only new or used items.
								In some categories, you can use a product finder search (SearchRequest)
								to only retrieve new or used items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeFeedback" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, each item in the result set also includes information about the seller's feedback.
								Controls the details to return for each listing (not the set of listings that match the query).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CharityID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							(in) Restricts listings to return only items that support the specified nonprofit charity organization. Retrieve CharityID values with GetCharities.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LocalSearchPostalCode" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Include local items in returning results near this postal code. This postal code is the basis for local search.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSearchResults -->
	<xs:element name="GetSearchResultsResponse" type="ns:GetSearchResultsResponseType"/>
	<xs:complexType name="GetSearchResultsResponseType">
		<xs:annotation>
			<xs:documentation>
				Response contains the item listings that have the specified keyword(s) in the 
				title, sub-title, and (optionally) the description. If the request uses any of 
				the optional filtering properties, the item listings returned are those 
				containing the keyword(s) and meeting the filter criteria. &lt;br&gt;&lt;br&gt;
				Not applicable to eBay Express or Half.com.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="SearchResultItemArray" type="ns:SearchResultItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the returned item listings, if any. The data for each listing is 
								returned in an ItemType object.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the maximum number of ItemType objects that can be returned in 
								SearchResultItemArray for any given call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the page of data returned by the current call. For instance, 
								for the first set of items can be returned, this field has a value of 
								one.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreItems" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								Indicates whether there are more items, not yet returned, that match the 
								search criteria.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the results of the pagination, including the total number of 
								pages of data that can be returned and the total number of items that can 
								be returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryArray" type="ns:CategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Statistical information about categories that contain items that match 
								the query, if any. Returns empty if no matches are found or when the 
								Categories filter was not passed in the request. (For categories 
								associated with specific items, see items returned in each search 
								result.) Shows the distribution of items across each category.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BuyingGuideDetails" type="ns:BuyingGuideDetailsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains URLs and other information about relevant buying guides (if 
								any), as well as the site's buying guide hub. Unavailable in the Sandbox 
								environment. Buying guides are useful to buyers who do not have a 
								specific product in mind. For example, a digital camera buying guide 
								could help a buyer determine what kind of digital camera is right for 
								them. Only returned for product finder searches (using 
								SearchRequest.SearchAttributes) and for searches that retrieve matching 
								categories along with item data (using Categories.CategoriesOnly=false).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StoreExpansionArray" type="ns:ExpansionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								No longer returned as of mid-February 2006 (because Store
								Inventory listings are no longer limited to searches within eBay Stores).
								Used to contain items that were listed in the Store Inventory Format,
								if the request specified that ExpandSearch was true. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
									<TagStatus>Obsolete</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="InternationalExpansionArray" type="ns:ExpansionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Can be returned if the request specifies that ExpandSearch is true. 
								Provides additional search results when a small result set would have 
								been returned with the original search. For example, on the US site (site 
								ID 0), if a search would normally result in fewer than 10 items, and 
								ExpandSearch is true, the search results are expanded to include (if 
								matching the query) the InternationalExpansionArray container for items, 
								as well as other containers. The InternationalExpansionArray container 
								contains items available from international sellers.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FilterRemovedExpansionArray" type="ns:ExpansionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Can be returned if the request specifies that ExpandSearch is true. 
								Provides additional search results when a small result set would have 
								been returned with the original search. For example, on the US site (site 
								ID 0), if a search would normally result in fewer than 10 items, and 
								ExpandSearch is true, the search results are expanded to include (if 
								matching the query) the FilterRemovedExpansionArray container for items, 
								as well as other containers. The FilterRemovedExpansionArray container 
								contains items that would be returned if filters such as PriceRangeFilter 
								are removed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AllCategoriesExpansionArray" type="ns:ExpansionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Can be returned if the request specifies that ExpandSearch is true. 
								Provides additional search results when a small result set would have 
								been returned with the original search. For example, on the US site (site 
								ID 0), if a search would normally result in fewer than 10 items, and 
								ExpandSearch is true, the search results are expanded to include (if 
								matching the query) the AllCategoriesExpansionArray container for items, 
								as well as other containers. The AllCategoriesExpansionArray container 
								contains items available if category filters are removed. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SpellingSuggestion" type="ns:SpellingSuggestionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Suggestion for a different spelling of the search term or terms, along 
								with the number of matching items that would have been returned if the 
								suggestions had been used. The suggestions are given in Text tags and the 
								suggestion for the first word is given before the suggestion for 
								subsequent words. Suggestions are based on correctly-spelled terms in 
								items, so suggestions vary over time and depend on whether a word or word 
								combination is in one or more items.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResults</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSearchResultsExpress -->
	<xs:element name="GetSearchResultsExpressRequest" type="ns:GetSearchResultsExpressRequestType"/>
	<xs:complexType name="GetSearchResultsExpressRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves brief details about active items that are listed on eBay Express, eBay
				catalog products that have been used to pre-fill data in these items, and a
				histogram that shows the distribution of items and catalog products across Express
				departments, aisles, and/or product types.&lt;br&gt;
				&lt;p&gt;This call only returns Express data for the site associated with the site
				ID that you specify in the request URL (for the SOAP API) or the X-EBAY-API-SITEID
				header (for the XML API). For example, if you specify site ID 0, then data for
				Express US is returned. &lt;br&gt;
				&lt;br&gt;
				Currently, this call is only supported for site ID 0 (Express US).
				&lt;br&gt;
				&lt;br&gt;
				The Sandbox does not support GetSearchResultsExpress.&lt;br&gt;
				&lt;br&gt;
				You can configure the call to retrieve only the item data, only the catalog
				product data, only the histogram, or any combination of these results. By default,
				the call returns brief summaries of each.&lt;br&gt;
				&lt;br&gt;
				&lt;b&gt;Item Results:&lt;/b&gt; For each item returned (if any), the response
				includes a brief set of details, such as the item price (including shipping). You
				can retrieve more or fewer details about each item by using the ItemDetails field.
				To retrieve other details about a given item, use a call like GetSellerList or
				GetItem.&lt;br&gt;
				&lt;br&gt;
				&lt;b&gt;Catalog Product Results:&lt;/b&gt; For each eBay catalog product returned
				(if any), the response includes a brief set of details, such as the minimum and
				maximum price of listings that have been pre-filled based on that product. You can
				retrieve more or fewer details about each product by using the ProductDetails
				field.&lt;br&gt;
				&lt;br&gt;
				&lt;b&gt;Histogram Results:&lt;/b&gt; Instead of grouping items by category, the
				Express search engine groups items into &lt;i&gt;domains&lt;/i&gt;. A domain is a
				set of items to which Express can apply a common set of search rules. Express
				supports three kinds of domains: &lt;i&gt;Product types&lt;/i&gt;,
				&lt;i&gt;aisles&lt;/i&gt;, and &lt;i&gt;departments&lt;/i&gt;, like a typical
				department store. (The fact that we call these "domains" is not important to
				buyers and sellers, but it can be helpful to understand the domain relationships
				when you are working with the API.)&lt;br&gt;
				&lt;br&gt;
				Listings with similar properties are classified into product type domains. For
				example, "DVDs &amp; Movies" is a product type domain. Think of a product type as
				a type of good or service that can be purchased and as a leaf domain (which cannot
				be the parent of other domains).&lt;br&gt;
				&lt;br&gt;
				&lt;span class="tablenote"&gt;&lt;b&gt;Note:&lt;/b&gt; An Express product type is
				not the same as an eBay catalog product. Some Express product types are associated
				with eBay catalog products, but other Express product types are not.&lt;/span&gt;
				&lt;br&gt;
				&lt;br&gt;
				When multiple product types share a common theme, Express groups them into an
				aisle or a department. For example, the Men's Jeans product type can be grouped
				with Men's Pants into a Men's Clothing aisle. When multiple aisles share a common
				theme, Express groups them into departments. For example, the Men's Clothing aisle
				can be grouped with a Men's Accessories aisle to form an Apparel &amp; Accessories
				department. If no groups make sense, a product type can stand alone without being
				grouped. For example, "DVDs &amp; Movies" would not be grouped with other product
				types like Men's Jeans, so "DVDs &amp; Movies" has no parent aisle or department.
				(From a user's perspective, this product type is elevated to look like a
				department, but in the API it is still classified as a product type.) Similarly,
				an aisle can stand alone without being grouped with other aisles into a
				department.&lt;br&gt;
				&lt;br&gt;
				See &lt;a
				href="http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=
				eBay_XML_API&amp;topic=ExpressSearch" target="_blank"&gt;Searching and Browsing
				eBay Express&lt;/a&gt; for more information about departments, aisles, and product
				types.
				&lt;p&gt;
				This call returns a histogram that shows the number of items and catalog products
				that were found in each department, aisle, and/or product type that matches your
				search criteria.&lt;br&gt;
				&lt;br&gt;
				The domain names and groupings are subject to change. They are determined by the
				Express search engine based on the items that are currently listed on Express as
				well as historical buyer behavior. This means you need to call
				GetSearchResultsExpress to determine the current domain names and their
				hierarchical relationships.&lt;br&gt;
				&lt;br&gt;
				&lt;span class="tablenote"&gt;&lt;b&gt;Note:&lt;/b&gt; A domain is a search notion
				only. That is, items are not stored in domains on eBay, and domains are not
				equivalent to eBay categories (although Express may choose to organize and name
				some domains to match eBay categories).&lt;/span&gt; &lt;br&gt;
				&lt;br&gt;
				&lt;b&gt;Search Tips:&lt;/b&gt;&lt;/p&gt;
				&lt;ul&gt;
					&lt;li&gt;Use either Query, ProductReferenceID, or the ExternalProductID fields
					to search for specific items and/or products. See the descriptions below for
					information about using these fields. (Only one of these query formats can be
					used per request.)&lt;/li&gt;
					&lt;li&gt;Use DepartmentName, AisleName, and/or ProductTypeName to browse or
					search within a particular domain. You can also specify the value "Express" in
					DepartmentName to retrieve a complete list of all available department, aisle,
					and product type names.&lt;/li&gt;
					&lt;li&gt;Use one or more filters like HighestPrice to refine the
					search.&lt;/li&gt;
					&lt;li&gt;Use sort options like ItemSort to control the order in which the
					results are returned.&lt;/li&gt;
					&lt;li&gt;Use pagination options like EntriesPerPage to control how many results
					to return at a time.&lt;/li&gt;
					&lt;li&gt;Use verbose controls like ItemDetails to specify the data to return
					within each result.&lt;/li&gt;
				&lt;/ul&gt;
				&lt;p&gt;The item results, catalog product results, and histogram results do not
				provide references to each other. That is, the items don't indicate which domains
				they were found in, and the histogram doesn't specify which items were counted.
				However, you can infer these relationships by modifying your search parameters.
				For example, once you determine which domains match your query, you can call
				GetSearchResultsExpress again to browse or search each of those domains to find
				out which items they contain.
				&lt;/p&gt;
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves brief details about active items that are listed on eBay Express,
						eBay catalog products that have been used to pre-fill data in these items, and
						a histogram that shows the distribution of items and catalog products across
						Express departments, aisles, and/or product types.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Query" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A free-text query that retrieves items, information about eBay catalog
								products that were used to list the items, and/or applicable domain
								details. For a quick, targeted search, use keywords that best fit the item
								you're looking for. You can also search by brand name or descriptive
								features. The search engine checks all specified keywords against the item
								title, description, eBay category, Item Specifics, and/or Pre-filled Item
								Information. (Express does not necessarily check all Item Specifics
								defined on the item.) The exact combination of fields that are checked for
								any given set of keywords varies by a number of factors that are not
								disclosed in this documentation.&lt;br&gt;
								&lt;br&gt;
								Specify at least two characters when you use Query. If you specify
								multiple words, AND logic is used. The keywords can be specified any
								order. The words "and" and "or" are treated like any other word. Only use
								"and", "or", or "the" if you are searching for listings containing these
								words.&lt;br&gt;
								&lt;br&gt;
								You can control AND or OR logic by including certain modifiers. Wildcards
								(e.g., *) are also supported. Be careful when using spaces before or after
								modifiers and wildcards (+, -, or *). These are the same modifiers that
								GetSearchResults supports. See "Searching by Keywords" in the eBay Web
								Services Guide for a list of valid modifiers and examples. Modifiers do
								not count in the 2-character minimum.
								&lt;br&gt;
								&lt;br&gt;
								Alternatively, you can specify an item ID to retrieve a specific item's
								Express search details. To search by ISBN or UPC, use
								ExternalProductIDType and ExternalProductIDValue instead.&lt;br&gt;
								&lt;br&gt;
								The Query, ProductReferenceID, and ExternalProductID query formats are
								mutually exclusive. That is, they cannot be used together in the same
								request. At least one of Query, ProductReferenceID, ExternalProductIDValue
								(and Type), SellerID, DepartmentName, AisleName, or ProductTypeName is
								required.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>350</MaxLength>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalProductIDType" type="ns:ExternalProductCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The combination of ExternalProductIDType and ExternalProductIDValue create
								a query that only retrieves items that were listed with Pre-filled Item
								Information in categories that support ISBN or UPC codes.
								ExternalProductIDType identifies whether the search is by ISBN or UPC. If
								specified, also specify the ISBN or UPC code in
								ExternalProductIDValue.&lt;br&gt;
								&lt;br&gt;
								The Query, ProductReferenceID, and ExternalProductID query formats are
								mutually exclusive. That is, they cannot be used together in the same
								request. At least one of Query, ProductReferenceID, ExternalProductIDValue
								(and Type), SellerID, DepartmentName, AisleName, or ProductTypeName is
								required.&lt;br&gt;
								&lt;br&gt;
								&lt;b&gt;Note:&lt;/b&gt; The ExternalProductID type and value structure is
								flat to support REST API requests in the future.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalProductIDValue" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An ISBN or UPC code (depending on ExternalProductIDType) for the eBay
								catalog product that you are searching for. Only valid when
								ExternalProductIDType is specified.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>15</MaxLength>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductReferenceID" type="xs:long" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The global reference ID for an eBay catalog product. eBay catalog products
								provide stock information that sellers can use to pre-fill Item Specifics
								and other listing details. Use this query to retrieve items that were
								listed with any version of the catalog product.&lt;br&gt;
								&lt;br&gt;
								To determine valid reference IDs, call GetSearchResultsExpress without
								using this value. The IDs that match the query (if any) are returned in
								ProductArray.Product.ProductReferenceID fields.&lt;br&gt;
								&lt;br&gt;
								&lt;b&gt;Note:&lt;/b&gt; This value is not the same as the ProductID used
								in AddItem and related calls. You cannot use this call or the catalog
								search calls to determine a relationship between ProductReferenceID and
								ProductID.&lt;br&gt;
								&lt;br&gt;
								The Query, ProductReferenceID, and ExternalProductID query formats are
								mutually exclusive. That is, they cannot be used together in the same
								request. At least one of Query, ProductReferenceID, ExternalProductIDValue
								(and Type), SellerID, DepartmentName, AisleName, or ProductTypeName is
								required.
							</xs:documentation>
							<xs:appinfo>
								<Min/>
								<Max/>
								<Default/>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DepartmentName" type="xs:string" minOccurs="0" maxOccurs="1">
						<xs:annotation>
							<xs:documentation>
								A department is a grouping of aisles and/or product types that share a
								common theme. This filter limits the search to the specified Express
								department. If not specified, this filter is ignored by the search
								engine.&lt;br&gt;
								&lt;br&gt;
								You can specify the value "Express" (without quotes) as the department
								name to retrieve all departments on Express. With this use case, the
								ItemArray and ProductArray nodes aren't returned. The valid department
								names are returned in the Histogram.Department.DomainDetails.Name fields.
								When DepartmentName=Express, you can only specify HistogramSort and/or
								HistogramDetails. Set HistogramDetail to Fine to also retrieve all aisles
								and product types. Do not specify ItemDetails or ProductDetails at all in
								the request. (Setting the values to None will return an error). Also do
								not specify any other query, pagination, price, or sorting fields in the
								request.&lt;br&gt;
								&lt;br&gt;
								The Query, ProductReferenceID, and ExternalProductID query formats are
								mutually exclusive. That is, they cannot be used together in the same
								request. At least one of Query, ProductReferenceID, ExternalProductIDValue
								(and Type), SellerID, DepartmentName, AisleName, or ProductTypeName is
								required.&lt;br&gt;
								&lt;br&gt;
								Note: The potential max length will be documented in a future release.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AisleName" type="xs:string" minOccurs="0" maxOccurs="1">
						<xs:annotation>
							<xs:documentation>
								An aisle is a grouping of product types that share a common theme. This
								filter limits the search to the specified Express aisle. If not specified,
								this filter is ignored by the search engine.&lt;br&gt;
								&lt;br&gt;
								See DepartmentName for information about how to retrieve all available
								department, aisle, and product type names. The valid aisle names are
								returned in the Histogram.Department.Aisle.DomainDetails.Name
								fields.&lt;br&gt;
								&lt;br&gt;
								At least one of Query, ProductReferenceID, ExternalProductIDValue (and
								Type), SellerID, DepartmentName, AisleName, or ProductTypeName is required.
								Optionally, both DepartmentName and AisleName can be specified in the same
								request. In this case, the search engine treats the combination as a fully
								qualified aisle name (and it returns an error if the combination is
								invalid).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductTypeName" type="xs:string" minOccurs="0" maxOccurs="1">
						<xs:annotation>
							<xs:documentation>
								A product type is a type of good or service that can be purchased. This
								filter limits the search to the specified Express product type. If not
								specified, this filter is ignored by the search engine.&lt;br&gt;
								&lt;br&gt;
								&lt;b&gt;Note:&lt;/b&gt; Express product types are not eBay catalog
								products. This field does not support eBay catalog product names or
								IDs.&lt;br&gt;
								&lt;br&gt;
								See DepartmentName for information about how to retrieve all available
								department, aisle, and product type names. The valid product type names
								are returned in Histogram.Department.Aisle.ProductType.DomainDetails.Name
								fields.&lt;br&gt;
								&lt;br&gt;
								Optionally, DepartmentName and/or AisleName can be specified in the same
								request with ProductTypeName. In this case, the search engine treats the
								combination as a fully qualified product type name (and it returns an
								error if the combination is invalid).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HistogramSort" type="ns:ExpressHistogramSortCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the order of the data in the histogram (if any). Controls the
								way the histogram data is organized in the response (not the details to
								return). If not specified, the default sort order is ItemCount.&lt;br&gt;
								&lt;br&gt;
								This option has no effect on how item or product results are sorted.
								Histogram, item, and product results are sorted independently.&lt;br&gt;
								&lt;br&gt;
								Note: If you want to sort the results by criteria that eBay has not
								defined, retrieve the desired histogram data and then sort the results
								locally in your application.
							</xs:documentation>
							<xs:appinfo>
								<Default>ItemCount</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemSort" type="ns:ExpressItemSortCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the order in which listings (if any) are returned in the result
								set. If not specified, the items are sorted by relevance (as determined by
								eBay). If you choose to sort by total cost, a PostalCode must also be
								specified (so that eBay can calculate the shipping cost as part of the
								total cost for each item).&lt;br&gt;
								&lt;br&gt;
								Controls the way the data is organized in the response (not the details to
								return).&lt;br&gt;
								&lt;br&gt;
								This option has no effect on how histogram or product results are sorted.
								Histogram, item, and product results are sorted independently.&lt;br&gt;
								&lt;br&gt;
								Note: If you want to sort the results by criteria that eBay has not
								defined, retrieve all available pages and then sort the results locally in
								your application.
							</xs:documentation>
							<xs:appinfo>
								<Default>Relevance</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductSort" type="ns:ExpressProductSortCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the order in which Express products are returned in a result
								set. If not specified, the products are sorted by sales rank (bestselling
								first).&lt;br&gt;
								&lt;br&gt;
								This option has no effect on how histogram or item results are sorted.
								Histogram, item, and product results are sorted independently.&lt;br&gt;
								&lt;br&gt;
								Note: If you want to sort the results by criteria that eBay has not
								defined, retrieve all available pages and then sort the results locally in
								your application.&lt;br&gt;
								&lt;br&gt;
								Controls the way the data is organized in the response (not the details to
								return).
							</xs:documentation>
							<xs:appinfo>
								<Default>SalesRank</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HighestPrice" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A filter that limits the results to items with a SellingStatus.CurrentPrice
								value lower than this value. For example, if you specify 10.01, the results
								will include items with a CurrentPrice of 10.00 or lower. Use without
								LowestPrice to specify a maximum price, or use with LowestPrice to define a
								price range that bounds the results. Must be higher than LowestPrice if both
								are specified. If not specified, no maximum price filter is applied to the
								query.&lt;br&gt;
								&lt;br&gt;
								You can specify any double value, but in practice the highest price of any
								item on Express is USD 10000 for Express US and (in the future) EUR 10000
								for Express Germany. If you specify a value of 0.0 or lower, this filter is
								ignored. See "Data Types" in the eBay Web Services Guide for information
								about specifying double values.&lt;br&gt;
								&lt;br&gt;
								Does not control the order in which items are returned. (To sort by highest
								total price, use ItemSort.)
							</xs:documentation>
							<xs:appinfo>
								<Min/>
								<Max/>
								<Default/>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LowestPrice" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A filter that limits the results to items with a
								SellingStatus.CurrentPrice value equal to or higher than this value. For
								example, if you specify 6.00, the results will include items with a
								CurrentPrice of 6.00 or higher. If specified, HighestPrice must also be
								specified; otherwise, the lowest price filter is ignored. Must be lower
								than HighestPrice. If not specified or if the value is less than 0.0, no
								minimum price filter is applied to the query.&lt;br&gt;
								&lt;br&gt;
								You can specify any double value, but in practice the highest price of any
								item on Express is USD 10000 for Express US and (in the future) EUR 10000
								for Express Germany. See "Data Types" in the eBay Web Services Guide for
								information about specifying double values .&lt;br&gt;
								&lt;br&gt;
								Does not control the order in which items are returned. (To sort by lowest
								total price, use ItemSort.)
							</xs:documentation>
							<xs:appinfo>
								<Min/>
								<Max/>
								<Default/>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Condition" type="ns:ConditionSelectionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A filter that limits the results by the item condition. If not specified,
								the default is New. If the item is listed in a category that does not
								normally require the condition to be specified (like Event Tickets), the
								item is returned regardless of this condition setting.
							</xs:documentation>
							<xs:appinfo>
								<Default>New</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A filter that limits the search to a particular seller's listings that are
								included on Express. Retrieves all of the seller's eligible items, without
								consolidating (deduping) similar items into single representative results.
								If specified, you can only search within one seller's listings per call.
								(It is not possible to exclude a particular seller's listings from the
								search.) If not specified, the engine searches across all listings on
								Express. If the seller has no items listed on Express, no results are
								returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PostalCode" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Postal code of the buyer. For the US site, this is a 5-digit zip code.
								(Other sites may support longer alphanumeric values in the future.) The
								postal code enables Express to calculate the item's default shipping cost
								based on the buyer's postal code, the postal code defined on the item, and
								the cost of the default shipping service that the seller specified in the
								listing. The default shipping cost is returned in the
								Item.ShippingDetails.DefaultShippingCost field. If not specified, items
								with calculated shipping will return an
								Item.ShippingDetails.ShippingRateErrorMessage string that indicates that a
								postal code is needed to calculate shipping.&lt;br&gt;
								&lt;br&gt;
								Required if ItemSort is set to LowestTotalCost or HighestTotalCost
								(because the total cost calculation depends on the shipping cost
								calculation).&lt;br&gt;
								&lt;br&gt;
								This is not a query or filter, so it has no effect on which items or
								products are returned.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>5</MaxLength>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HistogramDetails" type="ns:ExpressDetailLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Controls the amount of statistical data to return in the response. If not
								specified, the default is Coarse.&lt;br&gt;
								&lt;br&gt;
								This setting is not a filter that limits the search; it only configures
								how much detail to retrieve in the resulting histogram. This setting has
								no effect on the product or item details.
							</xs:documentation>
							<xs:appinfo>
								<Default>Coarse</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductDetails" type="ns:ExpressDetailLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Selects the set of fields to retrieve for each catalog product that
								matches the query. If not specified, the default is Coarse.&lt;br&gt;
								&lt;br&gt;
								This setting is not a filter that limits the search; it only configures
								which fields to retrieve for each product found. This setting has no
								effect on the histogram or item details.
							</xs:documentation>
							<xs:appinfo>
								<Default>Coarse</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemDetails" type="ns:ExpressDetailLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Selects the set of fields to retrieve for each item that matches the
								query. If not specified, the default is Coarse.&lt;br&gt;
								&lt;br&gt;
								This setting is not a filter that limits the search; it only configures
								which fields to retrieve for each item found. This setting has no effect
								on the histogram or product details.
							</xs:documentation>
							<xs:appinfo>
								<Default>Coarse</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EntriesPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The maximum number of entries to return in the ProductArray or ItemArray.
								That is, if you specify 10, then up to 10 products and up to 10 items are
								returned in the current call's response.&lt;br&gt;
								&lt;br&gt;
								If the number of entries found is less than the value specified in
								EntriesPerPage, then that number of entries is returned instead. For
								example, if you specify 10, Express might only return 4 products and 9
								items (if no more matches are found). If not specified, the default is 15.
							</xs:documentation>
							<xs:appinfo>
								<Min>1</Min>
								<Max>200</Max>
								<Default>15</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the number of the page of data to return in the current call. If
								not specified, the default is 1 (the first page).
							</xs:documentation>
							<xs:appinfo>
								<Min>1</Min>
								<Max/>
								<Default>1</Default>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSearchResultsExpress -->
	<xs:element name="GetSearchResultsExpressResponse" type="ns:GetSearchResultsExpressResponseType"/>
	<xs:complexType name="GetSearchResultsExpressResponseType">
		<xs:annotation>
			<xs:documentation>
The GetSearchResultsExpress response contains the listings that match the query or ID
specified in the request,
related eBay catalog product information, and a histogram showing the the quantity (count)
of matching items
in Express departments, aisles, and product types.
The results may be limited by filters that were specified in the request.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Histogram" type="ns:DomainHistogramType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Indicates the quantity of items and catalog products that fall into
							departments, aisles,
							and/or product types that match the criteria in the request.
							The sort order is controlled by the value of HistogramSort in the
							request.
							Only returned when matching data is found and HistogramDetails is
							Coarse (the default) or Fine.&lt;br&gt;
							&lt;br&gt;
							When HistogramDetails==Coarse and no DepartmentName, AisleName, or
							ProductTypeName is specified in the request, Express only returns
							histogram details for departments. In this particular case, Express
							returns no histogram details when no departments match the request.
							This could occur when Express only finds matching results in
							stand-alone product types or stand-alone aisles (because they aren't
							grouped into departments).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemArray" type="ns:ItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains a list of items on Express that match all the criteria
							specified in the request.
							The sort order is controlled by the value of ItemSort in the request.
							Only returned when matching data is found and ItemDetails is Coarse
							(the default) or Fine.&lt;br&gt;
							&lt;br&gt;
							If the same seller has listed multiple items with the same title and
							costs, only one of
							those items is returned by default. This is treated as a consolidated
							(deduped) search result item
							that represents the seller's other, identical items.
							If you want to retrieve all duplicates for an item, pass the seller's
							user ID in the SellerID field
							in the request. Use the results to identify items with duplicate
							titles and costs.&lt;br&gt;
							&lt;br&gt;
							Items can belong to multiple departments, aisles, or product types at
							any given time,
							and this information is not stored or returned in the item data. To
							determine which items
							are currently available in a given domain, specify the
							DepartmentName, AisleName, or ProductTypeName
							in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProductArray" type="ns:ProductArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains a list of eBay catalog products have been used to pre-fill
							listings
							that match the criteria specified in the request.
							The sort order is controlled by the value of ProductSort in the
							request.
							Only returned when matching data is found and ProductDetails is
							Coarse (the default) or Fine.
							To determine which products are currently available in a given
							domain,
							specify the DepartmentName, AisleName, or ProductTypeName in the
							request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EntriesPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the number of item and product results per page that you
								requested.
								To determine how many items or products were actually returned,
								count the number of Item nodes in ItemArray (if any) and the
								number of
								Product nodes in ProductArray (if any).
							</xs:documentation>
							<xs:appinfo>
								<Min>1</Min>
								<Max>200</Max>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                  Indicates the page of data returned by the current call.
							</xs:documentation>
							<xs:appinfo>
								<Min>1</Min>
								<Max/>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreEntries" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								If true, there are additional item and/or product results (on
								higher-numbered pages)
								that match the query.
								To retrieve them, call GetSearchResultsExpress again
								and increment the page number or specify a higher value for
								EntriesPerPage in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSearchResultsExpress</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<!--  Call: GetSellerEvents -->
	<xs:element name="GetSellerEventsRequest" type="ns:GetSellerEventsRequestType"/>
	<xs:complexType name="GetSellerEventsRequestType">
		<xs:annotation>
			<xs:documentation>
				Contains the inputs that control the items that are returned for seller events.
				This includes time-based filtering on the start time, end time, and/or modification
				time of the item listings.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
					Retrieves price changes, item revisions, description revisions,
					and other changes that have occurred within the last 48 hours
					related to a seller's eBay listings.
					Input is the user ID for the seller whose events are returned.
					GetSellerEvents returns zero, one, or multiple item events.
					The result set is filtered to include only events for those items
					that start, end, or are modified within a span of time delineated by input values. 
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								eBay user ID for the seller whose events are to be returned.
								If not specified, retrieves events for the user identified by
								the authentication token passed in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the earliest (oldest) date to use in a date range filter based
								on item start time. Must be specified if StartTimeTo is specified. Either
								the StartTime, EndTime, or ModTime filter must be specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the latest (most recent) date to use in a date range filter
								based on item start time. Must be specified if StartTimeFrom is specified.
								Either the StartTime, EndTime, or ModTime filter must be specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the earliest (oldest) date to use in a date range filter based
								on item end time. Must be specified if EndTimeTo is specified. Either the
								StartTime, EndTime, or ModTime filter must be specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the latest (most recent) date to use in a date range filter
								based on item end time. Must be specified if EndTimeFrom is specified.
								Either the StartTime, EndTime, or ModTime filter must be specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the earliest (oldest) date to use in a date range filter based
								on the time an item's record was modified. Must be specified if ModTimeTo
								is specified. Either the StartTime, EndTime, or ModTime filter must be
								specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the latest (most recent) date to use in a date range filter
								based on the time an item's record was modified. Must be specified if
								ModTimeFrom is specified. Either the StartTime, EndTime, or ModTime filter
								must be specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="NewItemFilter" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies that only new items are to be returned. NewItemFilter is an
								optional input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeWatchCount" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether to include WatchCount in Item nodes returned. WatchCount
								is the number of watches buyers have placed on the item from their My eBay
								accounts.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerEvents -->
	<xs:element name="GetSellerEventsResponse" type="ns:GetSellerEventsResponseType"/>
	<xs:complexType name="GetSellerEventsResponseType">
		<xs:annotation>
			<xs:documentation>
          Contains the items returned by the call. Items for which a seller event has
          occurred (and that meet any filters specified as input) are returned in an
          ItemArrayType object, within which are zero, one, or multiple ItemType objects.
          Each ItemType object contains the detail data for one item listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="TimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                      Indicates the latest (most recent) date for any date-based filtering specified as
                      input. Specifically, this field contains the value you specified in the StartTimeTo, EndTimeTo, or ModTimeTo filter, if you used a time filter in the request. If no time filter was specified, TimeTo returns the current time.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemArray" type="ns:ItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
                      Collection of Item objects, each of which represents an item listing
                      that incurred the type of seller event change specified in the call's
                      inputs. Returns empty if the seller has no item events within the 
                      time window indicated in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerEvents</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerList -->
	<xs:element name="GetSellerListRequest" type="ns:GetSellerListRequestType"/>
	<xs:complexType name="GetSellerListRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests a list of items a seller has listed for auction. Use no
				DetailLevel to return brief item information (ItemID, StartTime,
				and EndTime only). Use the DetailLevel ReturnAll to return all
				information on the item, including Item.Description. Use
				ItemReturnDescription to return a shorter item description (see
				the eBay Web Services Guide for details).
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves a list of the items a specified seller has
						listed on eBay. Input is the ID for the seller whose
						items are returned. Returns an array of
						zero, one, or multiple items for that seller. Inputs are
						provided to filter the returned items to just those that
						end within a specified date range or those items for
						which the listings start within a date range. A special
						set of inputs is provided to retrieve the list of items
						in smaller, more manageable chunks, or pages.
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="UserID" type="ns:UserIDType" minOccurs="0" maxOccurs="1">
						<xs:annotation>
							<xs:documentation>
								Specifies the seller whose items will be returned. UserID is an optional input.
								If not specified, the requesting user is the seller whose items are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MotorsDealerUsers" type="ns:UserIDArrayType" minOccurs="0" maxOccurs="1">
						<xs:annotation>
							<xs:documentation>
								Reserved for future use.
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the earliest (oldest) date to use in a date range filter based on item end time.
								Specify either the end time range or start time range filter in every request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the latest (most recent) date to use in a date range filter based on item end time.
								Must be specified if EndTimeFrom is specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Sort" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the order in which returned items are sorted (based on the end dates of the
								item listings). Valid values:&lt;br&gt;
									0 = No sorting&lt;br&gt;
									1 = Sort in descending order&lt;br&gt;
									2 = Sort in ascending order&lt;br&gt;
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the earliest (oldest) date to use in a date range filter based on item
								start time. Specify either the end time range or start time range filter in every request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the latest (most recent) date to use in a date range filter based on item
								start time. Must be specified if StartTimeFrom is specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the data controlling the pagination of the returned values: how many items
								are returned per page of data (per call) and the number of the page to return with
								the current call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="GranularityLevel" type="ns:GranularityLevelCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the subset of item and user fields to return.
								See GetSellerList in the eBay Web Services guide for a list
								of the fields that are returned for each granularity level.
								For GetSellerList, use DetailLevel or GranularityLevel in a request, but not both.
								For GetSellerList, if GranularityLevel is specified, DetailLevel is ignored.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SKUArray" type="ns:SKUArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies a set of seller SKUs to use as a filter. Only items with the specified SKUs are
								returned. Do not specify this tag if you do not want to filter by SKU. Corresponds to the SKU property
								that is part of ItemType and that can be provided when, for example, you use the AddItem call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeWatchCount" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether to include WatchCount in Item nodes returned.
								WatchCount is only returned with DetailLevel ReturnAll.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerList -->
	<xs:element name="GetSellerListResponse" type="ns:GetSellerListResponseType"/>
	<xs:complexType name="GetSellerListResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains a list of the items listed by the seller specified as input. The list of
				items is returned in an ItemArrayType object, in which are returned zero, one, or
				multiple ItemType objects. Each ItemType object contains the detail data for one
				item listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains information regarding the pagination of data (if pagination is 
								used), including total number of pages and total number of entries.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreItems" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, there are more items yet to be retrieved. Additional 
								GetSellerList calls with higher page numbers or more items per page must 
								be made to retrieve these items. Not returned if no items match the 
								request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemArray" type="ns:ItemArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the list of the seller's items, one ItemType object per item.
								Returns empty if no items are available that match the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the number of items that are being returned per page of data 
								(i.e., per call). Will be the same as the value specified in the 
								Pagination.EntriesPerPage input. Only returned if items are returned. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates which page of data was just returned. Will be the same as the 
								value specified in the Pagination.PageNumber input. (If the input is 
								higher than the total number of pages, the call fails with an error.)
								Only returned if items are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReturnedItemCountActual" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the total number of items returned (i.e., the number of 
								ItemType objects in ItemArray). 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Seller" type="ns:UserType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the seller whose items are returned. The seller is the eBay 
								member whose UserID was passed in the request. If UserID was not 
								specified, the seller is the user who made the request (identified by 
								eBayAuthToken).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerList</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerPayments -->
	<xs:element name="GetSellerPaymentsRequest" type="ns:GetSellerPaymentsRequestType"/>
	<xs:complexType name="GetSellerPaymentsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a summary of pending or paid payments that Half.com created for the
				seller identified by the authentication token in the request. Only retrieves
				payments that occurred within a particular pay period. Each payment is for one
				transaction for one item in one order. An order can contain transactions for
				multiple items from multiple sellers, but this call only retrieves payments that
				are relevant to one seller. The financial value of a payment is typically based on
				an amount that a buyer paid to Half.com for a transaction, with adjustments for
				shipping costs and Half.com's commission. For most sellers, each month contains
				two pay periods: One from the 1st to the 15th of the month, and one from the 16th
				to the last day of the month. Sellers can refer to their account information on
				the Half.com site to determine their pay periods. (You cannot retrieve a seller's
				pay periods by using eBay Web Services.) When a buyer makes a purchase and an
				order is created, Half.com creates a payment for the seller and marks it as
				Pending in the seller's Half.com account. Within a certain number of days after
				the pay period ends, Half.com settles payments for that period and marks each
				completed payment as Paid. See the Half.com Web site online help for more
				information about how payments are managed.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves a summary of pending or paid payments that Half.com
						created for the seller identified by the authentication token
						in the request.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="PaymentStatus" type="ns:RCSPaymentStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Filter to retrieve only items with the specified payment status (Paid or
								Pending). "Pending payments" are payments that Half.com has created but
								that have not yet been sent to the seller's financial institution. Pending
								payments are typically available once a buyer pays for an order. As
								Half.com processes payments by using periodic batch jobs, the
								GetSellerPayments response might not include a transaction's payment for
								up to 20 minutes after the buyer has paid. You can retrieve pending
								payments for the current pay period. Pending payments that have not been
								settled yet can also be retrieved for previous pay periods. "Paid
								payments" are payments that Half.com processed during previous pay
								periods. Paid payments might not appear in the seller's financial
								institution account balance until a certain number of days after the
								current pay period ends (see the Half.com online help for details). You
								can only retrieve paid payments for one previous pay period at a time.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Time range filter that retrieves Half.com payments that were created within
								a single pay period. Sellers can refer to the Half.com site to determine
								their pay periods. PaymentTimeFrom is the earliest (oldest) time and
								PaymentTimeTo is the latest (most recent) time in the range. Half.com pay
								periods start and end at midnight Pacific time, but the time values are
								stored in the database in GMT (not Pacific time). See "Time Values" in the
								eBay Web Services guide for information about converting between GMT and
								Pacific time. &lt;br&gt;
								&lt;br&gt;
								If you specify a PaymentStatus of Pending, add a buffer of one hour (or one
								day) to both ends of the time range to retrieve more data than you need, and
								then filter the results on the client side as needed. If any pending
								payments match the request, the response may include all payments since the
								beginning of the period. &lt;br&gt;
								&lt;br&gt;
								If you specify a PaymentStatus of Paid, the time range must contain one
								full pay period. That is, PaymentTimeFrom must be earlier or equal the
								start time of the pay period, and PaymentTimeTo must be later than or
								equal to the end time of the pay period. Otherwise, no paid payments are
								returned. For example, if the pay period starts on 2005-09-16 and ends on
								2005-09-30, you could specify an earlier PaymentTimeFrom value of
								2005-09-16T00:00:00.000Z and a later PaymentTimeTo value of
								2005-10-01T12:00:00.000Z. &lt;br&gt;
								&lt;br&gt;
								If you specify a time range that covers two pay periods, only the payments
								from the most recent pay period are returned. The earliest time you can
								specify is 18 months ago.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Time range filter that retrieves Half.com payments for a single pay
								period. See the description of PaymentTimeTo for details about using this
								time range filter. For paid payments, this value should be equal to or
								later than the end of the last day of the pay period, where the time is
								converted to GMT. For example, if the period ends on 2005-09-30, you could
								specify 2005-10-01T09:00:00.000Z, which is later than the end of the last
								day.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If many payments are available, you may need to call GetSellerPayments
								multiple times to retrieve all the data. Each result set is returned as a
								page of entries. Use this Pagination information to indicate the maximum
								number of entries to retrieve per page (i.e., per call), the page number
								to retrieve, and other data.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerPayments -->
	<xs:element name="GetSellerPaymentsResponse" type="ns:GetSellerPaymentsResponseType"/>
	<xs:complexType name="GetSellerPaymentsResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns a summary of pending or paid payments that Half.com created for the seller
				identified by the authentication token in the request. Only returns payments that
				occurred within a particular pay period. Each payment is for one transaction for
				one item in one order. An order can contain transactions for multiple items from
				multiple sellers, but this call only retrieves payments that are relevant to one
				seller. Payments are only issued for items and transactions that the seller has
				confirmed (see the Half.com online help for details). The financial value of a
				payment is typically based on an amount that a buyer paid to Half.com for a
				transaction, plus the shipping cost the buyer paid to Half.com for the item, minus
				Half.com's commission. For most sellers, each month contains two pay periods: One
				from the 1st to the 15th of the month, and one from the 16th to the last day of
				the month. Payments are submitted to the seller's financial institution a certain
				number of days after the current pay period ends (see the Half.com online help for
				details).
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains information regarding the pagination of data (if pagination is used),
							including total number of pages and total number of entries.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMorePayments" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, there are more payments yet to be retrieved. Additional
								GetSellerPayments calls with higher page numbers or more entries per page
								must be made to retrieve these payments. If false, no more payments are
								available or no payments match the request (based on the payment status
								and time filter).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerPayment" type="ns:SellerPaymentType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Information about a single payment that matches the criteria in the
								request. A payment is between Half.com and a seller. Each payment is for
								one transaction for one item in one order. An order can contain
								transactions for multiple items from multiple sellers, but this call only
								retrieves payments that are relevant to one seller. The financial value of
								a payment is typically based on an amount that a buyer paid to Half.com
								for a transaction, plus the shipping cost the buyer paid for the item,
								minus Half.com's commission. Payments can also describe refunds that the
								seller has issued. Multiple SellerPayment entries can be returned per page
								of results. Typically, they are returned in reverse chronological order
								(most recent PaidTime first). Only returned if payments exist that match
								the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the number of payments that can be returned per page of data
								(i.e., per call). This is the same as the value specified in the
								Pagination.EntriesPerPage input (or the default value, if EntriesPerPage
								was not specified). This is not necessarily the actual number of payments
								returned per page (see ReturnedPaymentCountActual).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates which page of data holds the current result set. Will be the
								same as the value specified in the Pagination.PageNumber input. (If the
								input is higher than the total number of pages, the call fails with an
								error.) If no payments are returned, the value is 0. If payments are
								returned, the first page number is 1.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReturnedPaymentCountActual" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the total number of payments returned (i.e., the number of
								SellerPayment entries returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerPayments</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerTransactions -->
	<xs:element name="GetSellerTransactionsRequest" type="ns:GetSellerTransactionsRequestType"/>
	<xs:complexType name="GetSellerTransactionsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a report containing information you can use to process the requesting
				seller's transactions. A transaction contains the information about the sale of
				one or more items by one buyer from a single listing. As some listings can return
				large numbers of transactions, use the supplied time filters to retrieve only
				those transactions whose status has been modified between two dates. Optionally,
				also configure the request to retrieve one page of data at a time (where each page
				contains a more manageable number of transactions). The user making the request
				can only retrieve their own transactions. That is, a user cannot retrieve all the
				transactions for another seller. If the user needs to retrieve transactions for
				another seller's listing, use GetItemTransactions instead.
				&lt;br&gt;&lt;br&gt;
				In general, only fields that are necessary for processing transactions are
				returned. For example, reserve price information would not be returned because the
				data is not relevant once the agreement to purchase the item has occurred. Also,
				fields that are not logically applicable are not returned. For example,
				TransactionArray.Transaction.Buyer.SellerInfo is not returned because the buyer is
				not acting in the role of a seller for the transaction.
				&lt;br&gt;&lt;br&gt;
				As the SellerType object is returned at the root level of the response, and as all
				transactions returned from this call are for the same seller, each individual
				Transaction.Item object does not return a SellerType object.
				&lt;br&gt;&lt;br&gt;
				Some fields that are defined on Transaction.Item (e.g.,
				Item.SellingStatus.QuantitySold) sound similar to fields defined on Transaction
				(e.g., QuantityPurchased). The difference is that the item fields are applicable
				across the entire listing; whereas the transaction fields are only applicable for
				the particular transaction identified. For example, suppose a listing has 20 items
				and 10 of them have sold. This would cause the
				Transaction.Item.SellingStatus.QuantitySold value to be set to 10. If one
				transaction returned from GetSellerTransactionsCall represents one buyer's
				purchase of 3 of those items, the Transaction.QuantityPurchased value would be set
				3 for that particular transaction.
				&lt;br&gt;&lt;br&gt;
				Notes:
				&lt;br&gt;
				- In the TransactionArray.Transaction.ShippingDetails object, only one of
				FlatShippingRate or CalculatedRate will be returned, depending on which one the
				seller set.
				&lt;br&gt;
				- In the Seller and Transaction.Item.Buyer objects, email and address data is only
				returned under certain conditions.
				&lt;br&gt;
				- The TransactionArray.Transaction.Item.ListingDetails.RelistItemID object is only
				returned if the item was re-listed.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves data for transactions created by the sale of
						items that were listed by the user making the request.
						GetSellerTransactions returns zero, one, or multiple
						transactions (depending on the sale of items from the
						listing and the listing type). Input values allow the
						result set to contain just those transactions created between two
						specified dates.
						The return data contains information you can use to
						process transactions.
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
				<SeeLink>
					<Title>Email and Address Privacy Policy</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=EmailPrivacyPolicy</URL>
					<For>the conditions under which buyer and seller email and address are returned</For>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ModTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the earliest (oldest) date to use in a date range filter based
								on the time a transaction's status was modified. Filters out transactions
								whose status was last modified before this date. The date range between
								ModTimeFrom to ModTimeTo cannot be greater than 30 days.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeTo" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Describes the latest (most recent) date to use in a date range filter based on the
								time a transaction's status was modified. Filters out transactions whose status
								was last modified after this date. The date range between ModTimeFrom to ModTimeTo
								cannot be greater than 30 days. It is considered a best practice to always pass
								the current date-time, to ensure that no data is missed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements control pagination of the output. Use its EntriesPerPage
								property to control the number of transactions to return per call and its
								PageNumber property to specify the page of data to return.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeFinalValueFee" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether to include final value fees in the response.
								For most listing types, the fee is returned in Transaction.FinalValueFee.
								For Dutch auctions that end with bids (not Buy It Now purchases), the fee
								is returned in Item.SellingStatus.FinalValueFee.
								The Final Value Fee for FixedPriceItem, StoresFixedPrice, and Buy It Now
								Dutch listing types is returned on a transaction by transaction basis.
								For all other listing types, including Chinese and Dutch (no Buy It Now
								purchases), the Final Value Fee is returned when the listing status is
								Completed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="IncludeContainingOrder" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								For future use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SKUArray" type="ns:SKUArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies a set of seller SKUs to use as a filter. Only items with the
								specified SKUs are returned. Do not specify this tag if you do not want to
								filter by SKU. Corresponds to the SKU property that is part of ItemType
								and that can be provided when, for example, you use the AddItem call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSellerTransactions -->
	<xs:element name="GetSellerTransactionsResponse" type="ns:GetSellerTransactionsResponseType"/>
	<xs:complexType name="GetSellerTransactionsResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns an array of transaction data for the seller specified in the request.
				The results can be used to create a report of data that is commonly
				necessary for end-of-auction processing.
				Zero, one, or many Transaction objects can be returned in the array.
				The set of transactions returned is limited to those that were modified between
				the times specified in the request's ModTimeFrom and ModTimeTo filters.
				The transactions returned are sorted by Transaction.Status.LastTimeModified,
				ascending order (that is, transactions that more recently were modified are returned last).
				Also returns information about the seller whose transactions were requested.
				If pagination filters were specified in the request, returns meta-data describing
				the effects of those filters on the current response and the estimated effects if
				the same filters are used in subsequent calls.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the total number of pages (TotalNumberOfPages) and the total number
								of entries (TotalNumberOfEntries) that could be returned given repeated calls
								that use the same selection criteria as the call that returned this response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreTransactions" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether there are additional transactions to retrieve.
								That is, indicates whether more pages of data are available to be
								returned, given the filters that were specified in the request.
								Returns false for the last page of data.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number of transactions returned per page (per call). May be a higher value
								than ReturnedTransactionCountActual if the page returned is the last page
								and more than one page of data exists.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Page number for the page of transactions the response returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ReturnedTransactionCountActual" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Number of transactions retrieved in the current page of results just returned.
								May be a lower value than TransactionsPerPage if the page returned is the last
								page and more than one page of data exists.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Seller" type="ns:UserType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains information about the seller whose transactions are being returned.
								See the reference guide for information about the fields of the Seller object
								that are returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<DetailLevels>none, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionArray" type="ns:TransactionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								List of Transaction objects representing the seller's recent sales.
								Each Transaction object contains the data for one purchase
								(of one or more items in the same listing).
								See the reference guide for more information about the fields that are returned
								for each transaction.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<DetailLevels>none, ReturnAll</DetailLevels>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PayPalPreferred" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether the seller has the preference enabled that shows that the seller
								prefers PayPal as the method of payment for an item. This preference is indicated on
								an item's View Item page and is intended to influence a buyer to use PayPal
								to pay for the item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSellerTransactions</CallName>
									<Returned>Always</Returned>
									<DetailLevels>none, ReturnAll, ItemReturnDescription</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStore -->
	<xs:element name="GetStoreRequest" type="ns:GetStoreRequestType"/>
	<xs:complexType name="GetStoreRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests data about a seller's eBay store. The caller must be the owner of an
				eBay store. The return value from GetStoreResponse is a StoreType, which contains
				the store's configuration, including the store name, URL, subscription level, and
				other data. You can set CategoryStructureOnly to True to retrieve information
				about the category hierarchy of the store only.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests data about a seller's eBay store.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryStructureOnly" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								 If this is set to True, only the category structure of the store is
								 returned. If this is not specified or set to False, the complete store
								 configuration is returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStore</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RootCategoryID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the category ID for the topmost category to return (along with
								the subcategories under it, the value of the LevelLimit property
								determining how deep). This tag is optional. If RootCategoryID is not
								specified, then the category tree starting at that root Category is
								returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStore</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LevelLimit" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								 Specifies the limit for the number of levels of the category hierarchy
								 to return, where the given root category is level 1 and its children are
								 level 2. Only categories at or above the level specified are returned.
								 This tag is optional. If LevelLimit is not set, the complete category
								 hierarchy is returned. Stores support category hierarchies up to 3
								 levels only.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStore</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStore -->
	<xs:element name="GetStoreResponse" type="ns:GetStoreResponseType"/>
	<xs:complexType name="GetStoreResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the data describing a seller's eBay store, including name, description,
				URL, and other information. The caller making the request must be the owner
				of an eBay store. If the authenticated caller does not have an eBay store, the
				response is an error. A successful response contains either the complete store
				configuration or information about the category hierarchy for the store only.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Store" type="ns:StoreType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The data describing the store configuration.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStore</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStoreCategoryUpdateStatus -->
	<xs:element name="GetStoreCategoryUpdateStatusRequest" type="ns:GetStoreCategoryUpdateStatusRequestType"/>
	<xs:complexType name="GetStoreCategoryUpdateStatusRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns the status of the processing progress for category structure changes
				specified with a SetStoreCategories request. Use this call to retrieve status
				when the SetStoreCategories call is being processed asynchronously.
				SetStoreCategories will be processed asynchronously when many listings are
				affected by the category structure changes.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns the status of the processing progress for category
						structure changes specified with a SetStoreCategories request.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="TaskID" type="xs:long" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The task ID returned by the SetStoreCategories call. If the
								SetStoreCategories call was processed asynchronously, the TaskID will be
								a positive number, otherwise the TaskID will be 0.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreCategoryUpdateStatus</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStoreCategoryUpdateStatus -->
	<xs:element name="GetStoreCategoryUpdateStatusResponse" type="ns:GetStoreCategoryUpdateStatusResponseType"/>
	<xs:complexType name="GetStoreCategoryUpdateStatusResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the store category structure update status, when a prior 
				SetStoreCategories call was processed asynchronously. If a SetStoreCategories 
				request affects many listings, then the category structure changes will be 
				processed asynchronously. If not many listings are affected by category structure 
				changes, the status is returned in the SetStoreCategories response.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Status" type="ns:TaskStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The status (Pending, InProgress, Complete, or Failed) of an update to the 
								store category structure. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreCategoryUpdateStatus</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStoreCustomPage -->
	<xs:element name="GetStoreCustomPageRequest" type="ns:GetStoreCustomPageRequestType"/>
	<xs:complexType name="GetStoreCustomPageRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the custom page or pages for the user's Store.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the custom page or pages for the user's Store.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="PageID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If a PageID is specified, then that page is returned, and
								the returned page contains the page Content.
								If no PageID is specified, then all pages are returned, without
								the page Content.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreCustomPage</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStoreCustomPage -->
	<xs:element name="GetStoreCustomPageResponse" type="ns:GetStoreCustomPageResponseType"/>
	<xs:complexType name="GetStoreCustomPageResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the custom page or pages for the user's Store.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CustomPageArray" type="ns:StoreCustomPageArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The custom page or custom pages.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreCustomPage</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>					
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStoreOptions -->
	<xs:element name="GetStoreOptionsRequest" type="ns:GetStoreOptionsRequestType"/>
	<xs:complexType name="GetStoreOptionsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the current list of Store configuration options.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the current list of Store configuration options.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStoreOptions -->
	<xs:element name="GetStoreOptionsResponse" type="ns:GetStoreOptionsResponseType"/>
	<xs:complexType name="GetStoreOptionsResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the current list of options for Store configurations.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="BasicThemeArray" type="ns:StoreThemeArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The current set of basic themes. Each basic theme definition
								specifies a valid color scheme for the theme.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AdvancedThemeArray" type="ns:StoreThemeArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The current set of advances themes. Unlike basic themes, you
								can use any color	scheme with an advanced theme. These themes 
								are suitable for more advanced customization.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="LogoArray" type="ns:StoreLogoArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The current set of Store logos. These logos are used in the Store header.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SubscriptionArray" type="ns:StoreSubscriptionArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The current set of eBay Store subscription tiers and corresponding 
								subscription prices.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MaxCategories" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The maximum number of categories in this store.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MaxCategoryLevels" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The maximum number of category levels in this store.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStoreOptions</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStorePreferences -->
	<xs:element name="GetStorePreferencesRequest" type="ns:GetStorePreferencesRequestType"/>
	<xs:complexType name="GetStorePreferencesRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a user's Store preferences.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves a user's Store preferences.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetStorePreferences -->
	<xs:element name="GetStorePreferencesResponse" type="ns:GetStorePreferencesResponseType"/>
	<xs:complexType name="GetStorePreferencesResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the Store preferences retrieved for a user.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="StorePreferences" type="ns:StorePreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The user's Store preferences.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetStorePreferences</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSuggestedCategories -->
	<xs:element name="GetSuggestedCategoriesRequest" type="ns:GetSuggestedCategoriesRequestType"/>
	<xs:complexType name="GetSuggestedCategoriesRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests a list of up to 10 categories with
				the highest percentage of listings whose titles or descriptions
				contain the keywords you specify.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests a list of up to 10 categories with
						the highest percentage of listings whose titles or descriptions
						contain the keywords you specify.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Query" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the search string, consisting of one or
								more words to search for in the listing title.
								The words "and" and "or" are treated like any other
								word.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>350 (characters)</MaxLength>
								<CallInfo>
									<CallName>GetSuggestedCategories</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetSuggestedCategories -->
	<xs:element name="GetSuggestedCategoriesResponse" type="ns:GetSuggestedCategoriesResponseType"/>
	<xs:complexType name="GetSuggestedCategoriesResponseType">
	  <xs:annotation>
	    <xs:documentation>
				Returns a list of categories with the highest number 
				of listings whose titles or descriptions contain the keywords 
				specified in a GetSuggestedCategoriesRequest.
	    </xs:documentation>
	  </xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="SuggestedCategoryArray" type="ns:SuggestedCategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains the categories that contain listings
							that match the query string in the request. The array
							can have up to 10 categories. Not returned if no categories match 
							the query in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSuggestedCategories</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
					  </xs:annotation>
					</xs:element>
					<xs:element name="CategoryCount" type="xs:int" minOccurs="0">
					  <xs:annotation>
					    <xs:documentation>
								Indicates the number of categories in the array.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetSuggestedCategories</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
					  </xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetTaxTable -->
	<xs:element name="GetTaxTableRequest" type="ns:GetTaxTableRequestType"/>
	<xs:complexType name="GetTaxTableRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves the tax table for a user on a given site or retrieves the valid jurisdictions (if any) for a given site.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves the tax table for a user on a given site or retrieves the valid
						jurisdictions (if any) for a given site.
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetTaxTable -->
	<xs:element name="GetTaxTableResponse" type="ns:GetTaxTableResponseType"/>
	<xs:complexType name="GetTaxTableResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to GetTaxTableRequest.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="LastUpdateTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The last time (in GMT) that the tax table was updated.
								Only returned if the user previously created a tax table
								and if the site has jurisdictions.
								LastUpdateTime is useful for synchronization. If you cache the user's
								tax table, you can use GetTaxTable to check if it has changed and
								whether you need to update the cached tax table.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetTaxTable</CallName>
									<Returned>Conditionally</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TaxTable" type="ns:TaxTableType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A container of tax jurisdiction information unique to
								a user/site combination. Empty if not set for user.
								If DetailLevel is not specified, information is only
								returned for the jurisdictions for which the user provided tax
								information. If DetailLevel is ReturnAll, tax information
								is returned for all possible jurisdictions, whether
								specified by the user or not. ShippingIncludedInTax and
								SalesTaxPercent are returned but are empty.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetTaxTable</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUser -->
	<xs:element name="GetUserRequest" type="ns:GetUserRequestType"/>
	<xs:complexType name="GetUserRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves information about a user. Inputs controls what user
				data is returned. This includes the eBay user ID for the user
				whose data is to be returned and the item ID for a listing to
				indicate a transactional relationship between the requestor and
				the target user.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves data for one eBay user. Input is the eBay user
						ID for the user about whom to return data.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
 								Specifies the item ID for a successfully concluded listing in which
								the requestor and target user were participants (one as seller and
								the other as buyer). Necessary to return certain data (like an email
								address). Not necessary of the requestor is retrieving own data.
								ItemID is an optional input.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetUser</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the user whose data will returned by the call. UserID is
								optional. If not specified, the user data returned is that for
								the requesting user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUser</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUser -->
	<xs:element name="GetUserResponse" type="ns:GetUserResponseType"/>
	<xs:complexType name="GetUserResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the data retrieved by the call. User data is returned in a User object.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="User" type="ns:UserType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the returned user data for the specified eBay user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUser</CallName>
									<DetailLevels>none, ReturnAll</DetailLevels>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUserContactDetails -->
	<xs:element name="GetUserContactDetailsRequest" type="ns:GetUserContactDetailsRequestType"/>
	<xs:complexType name="GetUserContactDetailsRequestType">
		<xs:annotation>
			<xs:documentation>
				Returns contact information for a specified user if a
				bidding relationship exists between them. That is, the
				bidder must be bidding on the seller's active
				item, or an eBay user must have made an offer on
				the item via Best Offer.
				The item must be in the Motors or Business &amp; Industrial categories.
				Note that GetUserContactDetails does NOT return an email address.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Returns contact information for a specified user. Sellers
						can retrieve contact information for both bidders and
						users who have made offers (via Best Offer) during an
						active listing. Buyers can also use this call to contact
						sellers of an item they are bidding on or have made an
						offer on (via Best Offer). Note that this call does not
						return an email address. Sellers who wish to send an
						email message to their bidders should use
						AddMemberMessagesAAQToBidder instead.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An eBay ID that uniquely identifies a given
								item. Must be a currently active item.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>GetUserContactDetails</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ContactID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An eBay ID that uniquely identifies a given
								user. The same as the contact's eBay username.
								Either the seller's or bidder's username may be
								specified here, as long as a bidding
								relationship exists between them. That is, the
								bidder must be bidding on the seller's active
								item, or an eBay user must have made an offer on
								the item via Best Offer.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserContactDetails</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RequesterID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An eBay ID that uniquely identifies a given
								user. The same as the seller's eBay username.
								Either the seller's or bidder's username may be
								specified here, as long as a bidding
								relationship exists between them. That is, the
								bidder must be bidding on the seller's active
								item, or an eBay user must have made an offer on
								the item via Best Offer.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserContactDetails</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUserContactDetails -->
	<xs:element name="GetUserContactDetailsResponse" type="ns:GetUserContactDetailsResponseType"/>
	<xs:complexType name="GetUserContactDetailsResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns contact information to a seller for both bidders
				and users who have made offers (via Best Offer) during
				an active listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="UserID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An eBay ID that uniquely identifies a given
								user. The eBay username of the requested
								contact.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserContactDetails</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ContactAddress" type="ns:AddressType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contact information for the requested contact.
								Note that the email address is NOT returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserContactDetails</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RegistrationDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The date and time that the requested contact
								registered with eBay.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserContactDetails</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUserDisputes -->
	<xs:element name="GetUserDisputesRequest" type="ns:GetUserDisputesRequestType"/>
	<xs:complexType name="GetUserDisputesRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests a list of disputes the requester is involved in as buyer or seller.
				The list includes both Unpaid Item and Item Not Received disputes and can
				be filtered according to DisputeFilterType. Use a DetailLevel of ReturnAll to
				return all data about each dispute, including DisputeResolution and DisputeMessage
				elements.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests a list of disputes the requester is involved in as buyer or seller.
					</Summary>
				</Overview>
				<TempInfo>dl</TempInfo>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="DisputeFilterType" type="ns:DisputeFilterTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A filter that specifies a subset of disputes to return. The return list
								includes both Item Not Received and Unpaid Item disputes.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisputeSortType" type="ns:DisputeSortTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The value and sequence to use to sort the returned disputes.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeFrom" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							A filter that retrieves disputes whose DisputeModifiedTime is later
							than or equal to this value. Specify the time value in GMT.
							See the eBay Web Services documentation for information about specifying time values.
							For more precise control of the date range filter, it is a good practice to also
							specify ModTimeTo. Otherwise, the end of the date range is the present time.
							Filtering by date range is optional. You can use date range filters in combination
							with other filters like DisputeFilterType to control the amount of data returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModTimeTo" type="xs:dateTime" minOccurs="0">
					<xs:annotation>
						<xs:documentation>
							A filter that retrieves disputes whose DisputeModifiedTime is earlier
							than or equal to this value. Specify the time value in GMT.
							See the eBay Web Services documentation for information about specifying time values.
							For more precise control of the date range filter, it is a good practice to also
							specify ModTimeFrom. Otherwise, all available disputes modified prior to the ModTimeTo value are returned.
							Filtering by date range is optional. You can use date range filters in combination
							with other filters like DisputeFilterType to control the amount of data returned.
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetUserDisputes</CallName>
								<RequiredInput>No</RequiredInput>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The virtual page number of the result set to display. A result set has a number of disputes
								divided into virtual pages, with 200 disputes per page. The response can only display one page.
								The first page in the result set is number 1. Required. If not specified, a warning is returned
								and Pagination.PageNumber is set to 1 by default.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUserDisputes -->
	<xs:element name="GetUserDisputesResponse" type="ns:GetUserDisputesResponseType"/>
	<xs:complexType name="GetUserDisputesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns a list of disputes that involve the calling user
				as buyer or seller, in response to a GetUserDisputesRequest.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="StartingDisputeID" type="ns:DisputeIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The index of the first dispute in the current result set, relative
								to the total number of disputes available.
								Primarily useful for interpreting paginated results.
								For example, if 228 disputes are available and
								200 results are returned per page: The first page returns
								a StartingDisputeID value of 1 and the second page returns a
								StartingDisputeID value of 201.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndingDisputeID" type="ns:DisputeIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The index of the last dispute in the current result set, relative
								to the total number of disputes available.
								Primarily useful for interpreting paginated results.
								For example, if 228 disputes are available and
								200 results are returned per page: The first page returns
								an EndingDisputeID value of 200 and the second page returns an
								EndingDisputeID value of 228.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisputeArray" type="ns:DisputeArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The array of disputes returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The number of disputes on each virtual page in the result set.
								The virtual page returned is determined by PageNumber.
								Default is 200.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The page of the total result set returned in the call. The entire result set
								is virtual and the call returns only one page of it.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisputeFilterCount" type="ns:DisputeFilterCountType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The number of disputes that involve the requester as
								buyer or seller and match a given filter type.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The result of the pagination, including the total number
								of virtual pages in the result set and the total number of
								disputes returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserDisputes</CallName>
									<Returned>Always</Returned>
									<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUserPreferences -->
	<xs:element name="GetUserPreferencesRequest" type="ns:GetUserPreferencesRequestType"/>
	<xs:complexType name="GetUserPreferencesRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves some or all of a user's preferences. The set of preferences retrieved depends
				on the set of flags specified in the request.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves some or all of a user's preferences.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ShowBidderNoticePreferences" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								If true, requests a seller's preferences for receiving bidder notices.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShowCombinedPaymentPreferences" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								If true, requests a seller's preferences for accepting payments
								that combine item purchases into one order.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShowCrossPromotionPreferences"  type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								If true, requests a seller's cross-promotion preferences, such as
								whether cross-promotions are enabled and the sort filters used.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShowSellerPaymentPreferences"  type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
								If true, displays a seller's payment preferences, for displaying
								a Pay Now button, accepting PayPal, and so on.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShowEndOfAuctionEmailPreferences"  type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, displays the seller's end of auction email preferences.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
					  </xs:annotation>
					</xs:element>
					<xs:element name="ShowSellerFavoriteItemPreferences" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, retrieves preferences the seller has set for displaying items
								on a buyer's favorite sellers page and in the favorite sellers email digest.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShoweBxOptInPreference" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, displays the seller's preference regarding
								whether they want their eligible listings to be included on eBay Express.&lt;br&gt;
								&lt;br&gt;
								As of release 463, this flag is no longer recommended.
								Instead, the ExpressPreferences node will always be returned if the user is
								eligible for Express, and it will never be returned if the user is not eligible.
								That is, there is no "Show" filter to retrieve the ExpressPreferences node.
								Express preferences are dependent on the user's site of registration, not
								the site to which you send the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
									<TagStatus>Obsolete</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
						</xs:element>
						<xs:element name="ShowProStoresPreferences" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, returns ProStores checkout preferences.
							</xs:documentation>
							<xs:appinfo>
								<Default>false</Default>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
						</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetUserPreferences -->
	<xs:element name="GetUserPreferencesResponse" type="ns:GetUserPreferencesResponseType"/>
	<xs:complexType name="GetUserPreferencesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns some or all of a user's preferences. The preferences are grouped
				in sets, according to the sets requested.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="BidderNoticePreferences" type="ns:BidderNoticePreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a seller's preferences for receiving bidder notices.
								Returned when the request sets ShowBidderNoticePreferences to true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CombinedPaymentPreferences" type="ns:CombinedPaymentPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a seller's preferences for accepting combined payments.
								Returned when ShowCombinedPaymentPreferences is true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CrossPromotionPreferences" type="ns:CrossPromotionPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a seller's cross-promotion preferences.
								Returned when ShowCrossPromotionPreferences is true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerPaymentPreferences" type="ns:SellerPaymentPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a seller's preferences for accepting payments.
								Returned when ShowSellerPaymentPreferences is true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerFavoriteItemPreferences" type="ns:SellerFavoriteItemPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a seller's preferences for displaying items on a buyer's
								Favorite Sellers' Items page or Favorite Sellers' Items digest.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndOfAuctionEmailPreferences" type="ns:EndOfAuctionEmailPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the user's end of auction email preferences.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="eBxOptInPreference" type="ns:eBxOptInPreferenceType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Contains a seller's eBay Express preference regarding
							whether they want their eligible listings to be included on eBay Express.
							Returned when the request sets ShoweBxOptInPreference to true.&lt;br&gt;
							&lt;br&gt;
							As of release 463, applications should start using ExpressPreferences instead.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
									<TagStatus>Deprecated</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExpressPreferences" type="ns:ExpressPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The seller's Express preferences.
								Always returned for sellers who are eligible to list on Express.
								Not returned for sellers who are not eligible per eBay's requirements.
								If ExpressPreferences is not returned, call GetUser and check the value
								of SellerInfo.ExpressEligible. If the seller is not eligible, see
								"eBay Express" in the eBay Web Services guide for possible reasons.
								Note that if the seller opts out of Express themselves (but would otherwise be eligible),
								ExpressPreferences is returned. In this case, GetUser may show that the user is
								not eligible to list on Express.&lt;br&gt;
								&lt;br&gt;
								Express preferences are returned based on the seller's registration site,
								not the site to which you send the request. For example, a US seller's
								preferences will be returned even if you submit the request to site 77 (Germany).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ProStoresPreference" type="ns:ProStoresCheckoutPreferenceType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Details about ProStores and checkout preferences.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetUserPreferences</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetWantItNowPost -->
	<xs:element name="GetWantItNowPostRequest" type="ns:GetWantItNowPostRequestType"/>
	<xs:complexType name="GetWantItNowPostRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests data for a specific, active Want It Now post identified by a post ID.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests data for a specific, active Want It Now post identified by a post ID.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="PostID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the post ID that uniquely identifies the Want It Now post for
								which to retrieve the data. PostID is a required input. PostID is unique
								across all eBay sites.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowPost</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetWantItNowPost -->
	<xs:element name="GetWantItNowPostResponse" type="ns:GetWantItNowPostResponseType"/>
	<xs:complexType name="GetWantItNowPostResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains the Want It Now post data returned by the call. The data for the 
				specified post listing is returned in a WantItNowPostType object.
 			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="WantItNowPost" type="ns:WantItNowPostType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the data defining a single Want It Now post. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowPost</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetWantItNowSearchResults -->
	<xs:element name="GetWantItNowSearchResultsRequest" type="ns:GetWantItNowSearchResultsRequestType"/>
	<xs:complexType name="GetWantItNowSearchResultsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves a list of active Want It Now posts that match specified keywords and/or other
				search criteria.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves a list of active Want It Now posts that match specified keywords and/or other
						search criteria.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Limits the result set to just those Want It Now posts listed in the
								specified category. Defaults to all categories if no category ID is
								specified. If the specified category ID does not match an existing
								category for the site, an invalid-category error message is returned.
								Controls the set of listings to return (not the details to return for each
								listing).
								You must specify a Query and/or a CategoryID in the request.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Query" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies a search string. The search string consists of one or more
								keywords to search for in the listing title. Note that the post
								description will also be searched if SearchInDescription is enabled.
								By default, requests return a list of Want It Now posts that include all
								of the keywords specified in the Query. All words used in the query,
								including "and," "or," and "the,"  will be treated as keywords. You can,
								however, use modifiers and wildcards (e.g., +, -, and *) in the Query
								field to create more complex searches. Be careful when using spaces before
								or after modifiers and wildcards (+, -, or *), as the spaces can affect
								the query logic.
								See the eBay Web Services Guide for a list of valid search keyword query
								operators and examples.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>350 (characters)</MaxLength>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchInDescription" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, include the description field of Want It Now posts in the keyword search. Want
								It Now posts returned are those where specified search keywords appear in
								either the description or the title. This is the default behavior if SearchInDescription
								is not specified. If false, only the title will be searched. SearchInDescription is an
								optional input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SearchWorldwide" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, the search applies to all eBay sites. If false, the search is
								limited to the site specified in the URL query string when the call is
								made.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Controls the pagination of the result set. Child elements specify the
								maximum number of item listings to return per call and which page of data
								to return.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GetWantItNowSearchResults -->
	<xs:element name="GetWantItNowSearchResultsResponse" type="ns:GetWantItNowSearchResultsResponseType">
		<xs:annotation>
			<xs:documentation>
				Response contains the Want It Now posts that have the specified keyword(s) in the 
				title and (optionally) the description. 
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GetWantItNowSearchResultsResponseType">
		<xs:annotation>
			<xs:documentation>
				Response contains the Want It Now posts that have the specified keyword(s) in the 
				title and (optionally) the description. 
 			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="WantItNowPostArray" type="ns:WantItNowPostArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the returned Want It Now posts, if any. The data for each post is 
								returned in a WantItNowPostType object. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="HasMoreItems" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates whether there are additional Want It Now posts that meet the 
								search criteria. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemsPerPage" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the maximum number of Want It Now posts that can be returned in 
								a WantItNowPostArray for a request. This value can be specified in the 
								request by  EntriesPerPage in Pagination in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PageNumber" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the page of data returned by the current call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the results of the pagination, including the total number of 
								pages of data there are to be returned and the total number of posts there 
								are to be returned.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GetWantItNowSearchResults</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GeteBayDetails -->
	<xs:element name="GeteBayDetailsRequest" type="ns:GeteBayDetailsRequestType"/>
	<xs:complexType name="GeteBayDetailsRequestType">
		<xs:annotation>
			<xs:documentation>
				Retrieves eBay IDs and codes (e.g., site IDs and shipping service
				codes), enumerated data (e.g., payment methods), and other common eBay
				meta-data. This call enables you to keep certain data up to date in your
				applications without referring to the schema, the documentation, or the
				eBay online help. Other data is returned for your reference, but you may
				need to refer to the schema or the documentation for information about
				valid values and usage.
				&lt;br&gt;&lt;br&gt; In some cases, the data returned in the response
				will vary according to the site that you use for the request.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Retrieves eBay IDs and codes (e.g., site IDs and shipping service
						codes), enumerated data (e.g., payment methods), and other common
						eBay meta-data.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="DetailName" type="ns:DetailNameCodeType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								A designation of what kind of information you wish returned
								for the specified eBay site. If omitted, all details are
								returned.
								The possible values for input (the enumeration values of
								DetailNameCodeType) are the same name as fields returned by
								the response. See the documentation for the
								GeteBayDetails response to better understand the DetailName
								options.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GeteBayDetails -->
	<xs:element name="GeteBayDetailsResponse" type="ns:GeteBayDetailsResponseType">
		<xs:annotation>
			<xs:documentation>
				Details about a specified site in response to GeteBayDetailsRequest.
				If no DetailName is identified in the request, all elements of
				GeteBayDetailsResponse are returned. Otherwise, only the element
				corresponding to the specified DetailName is returned.
			</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="GeteBayDetailsResponseType">
		<xs:annotation>
			<xs:documentation>
				Details about a specified site in response to GeteBayDetailsRequest.
				If no DetailName is identified in the request, all elements of
				GeteBayDetailsResponse are returned. Otherwise, only the element
				corresponding to the specified DetailName is returned.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CountryDetails" type="ns:CountryDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific country. GeteBayDetails returns all countries in
								the system, regardless of the site to which you sent the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CurrencyDetails" type="ns:CurrencyDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific currency that can be used for listing on an eBay
								site. GeteBayDetails returns all site currencies in the system, regardless
								of the site to which you sent the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DispatchTimeMaxDetails" type="ns:DispatchTimeMaxDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific max dispatch time. A dispatch time specifies the
								maximum number of business days a seller commits to for shipping an item
								to domestic buyers after receiving a cleared payment. GeteBayDetails
								returns all dispatch times in the system, regardless of the site to which
								you sent the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentOptionDetails" type="ns:PaymentOptionDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific buyer payment method. GeteBayDetails only returns
								payment methods that are applicable to the site to which you sent the
								request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RegionDetails" type ="ns:RegionDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific geographical region. GeteBayDetails only returns
								regions that are applicable to the site to which you sent the request.
								However, you should ignore region values for all sites except China.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingLocationDetails" type="ns:ShippingLocationDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a location or region to which the seller is willing to ship.
								GeteBayDetails returns all shipping locations in the system, regardless of
								the site to which you sent the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingServiceDetails" type="ns:ShippingServiceDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific shipping service. GeteBayDetails only returns
								shipping services that are applicable to the site to which you sent the
								request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SiteDetails" type ="ns:SiteDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific eBay site. GeteBayDetails returns all sites in
								the system, regardless of the site to which you sent the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TaxJurisdiction" type="ns:TaxJurisdictionType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific tax jurisdiction or tax region. GeteBayDetails
								only returns jurisdictions that are applicable to the site to which you
								sent the request.&lt;br&gt;&lt;br&gt;
								Related fields:&lt;br&gt;
								TaxTable.TaxJurisdiction in SetTaxTable&lt;br&gt;
								Item.UseTaxTable in Additem
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="URLDetails" type="ns:URLDetailsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Details about a specific eBay URL. GeteBayDetails only returns URLs that
								are applicable to the site to which you sent the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>GeteBayDetails</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GeteBayOfficialTime -->
	<xs:element name="GeteBayOfficialTimeRequest" type="ns:GeteBayOfficialTimeRequestType"/>
	<xs:complexType name="GeteBayOfficialTimeRequestType">
		<xs:annotation>
			<xs:documentation>
				Gets the official eBay system time in GMT.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Gets the official eBay system time in GMT.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: GeteBayOfficialTime -->
	<xs:element name="GeteBayOfficialTimeResponse" type="ns:GeteBayOfficialTimeResponseType"/>
	<xs:complexType name="GeteBayOfficialTimeResponseType">
		<xs:annotation>
			<xs:documentation>
				The Timestamp field indicates the official eBay system time in GMT.
				For information about converting between GMT and other time zones, 
				see "Time Values" in the Data Types appendix in the eBay Web Services guide.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: IssueRefund -->
	<xs:element name="IssueRefundRequest" type="ns:IssueRefundRequestType"/>
	<xs:complexType name="IssueRefundRequestType">
		<xs:annotation>
			<xs:documentation>
				Issues a refund for a single Half.com transaction. Can only be
				called by a seller. Refunds may only be issued for a specific
				transaction. Sellers do not have the ability to issue a general
				refund (not tied to a transaction) to a buyer.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Issues a refund for a single Half.com transaction.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the Half.com item associated with the refund payment to the buyer.
								To uniquely identify a transaction, you need to specify both ItemID
								and TransactionID. Use GetSellerPayments to determine the item ID
								and transaction ID associated with the original sale payment.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the Half.com transaction associated with the refund payment.
								To uniquely identify a transaction, you need to specify both ItemID
								and TransactionID. Use GetSellerPayments to determine the item ID
								and transaction ID associated with the original sale payment.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RefundReason" type="ns:RefundReasonCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Explanation of the reason that the refund is being issued.
						</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RefundType" type="ns:RefundTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Explanation of the costs that the refund amount covers.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RefundAmount" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The amount the seller wants to refund to the buyer, in US Dollars (USD).
								Must be greater than 0.00. Half.com allows a maximum of the original item
								sale price (transaction price plus original shipping reimbursement) plus
								return shipping costs (the amount the buyer paid to return the item).
								Typically, the return shipping cost is based on the current cost of
								shipping the individual item (not the discounted cost calculated during
								the original checkout for a multi-item order). You can also issue a
								partial refund for the amount you want the buyer to receive. If
								RefundType=Full or RefundType=FullPlusShipping and you do not pass
								RefundAmount in the request, Half.com will calculate the refund amount for
								you. If you pass RefundAmount in the request, the amount you specify will
								override Half.com's calculated value. Required if RefundType=
								CustomOrPartial.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RefundMessage" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Note to the buyer. Cannot include HTML.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>400</MaxLength>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: IssueRefund -->
	<xs:element name="IssueRefundResponse" type="ns:IssueRefundResponseType"/>
	<xs:complexType name="IssueRefundResponseType">
		<xs:annotation>
			<xs:documentation>
Indicates the refund amount that a seller issued to a buyer for a single Half.com transaction.
Refunds may only be issued for a specific transaction. Sellers do not have the ability to issue a 
general refund (not tied to a transaction) to a buyer.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="RefundFromSeller" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Total amount that the seller asked Half.com to refund to 
							a buyer for a Half.com transaction.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TotalRefundToBuyer" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							Total amount that Half.com refunded to the buyer (which could include the refund amount 
							from the seller plus a refund amount from Half.com).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>IssueRefund</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: LeaveFeedback -->
	<xs:element name="LeaveFeedbackRequest" type="ns:LeaveFeedbackRequestType"/>
	<xs:complexType name="LeaveFeedbackRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a user to leave feedback about another user. Both users (the
				sender  and the recipient) must have a transactional relationship.
				That is, they must have both been participants in a successfully
				concluded item sale transaction that took place no more than 90 days
				prior. Also, the sending user cannot have already left feedback for
				the recipient for the transaction.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a user to leave feedback about another user.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Item ID for the listing from which the transaction relating the users
								(the feedback sender and recipient). Transaction must not have been
								created more than 90 days prior to the attempt to leave feedback.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>LeaveFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CommentText" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Textual comment that explains, clarifies, or justifies the feedback
								score specified in CommentType.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>LeaveFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CommentType" type="ns:CommentTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Score for the feedback being left. May be Positive, Neutral, or
								Negative.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>LeaveFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The item purchase transaction from the listing specified in ItemID for
								which the feedback is being left. Required if the listing identified in
								ItemID was a multi-item listing (Dutch auction or multi-item fixed-price
								listing).
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>LeaveFeedback</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TargetUser" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the recipient user about whom the feedback is being left.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>LeaveFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: LeaveFeedback -->
	<xs:element name="LeaveFeedbackResponse" type="ns:LeaveFeedbackResponseType"/>
	<xs:complexType name="LeaveFeedbackResponseType">
		<xs:annotation>
			<xs:documentation>
          LeaveFeedback response message includes an acknowledgement if the
          feedback was successfully left.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="FeedbackID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) The ID of the feedback that has been left.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>LeaveFeedback</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: PlaceOffer -->
	<xs:element name="PlaceOfferRequest" type="ns:PlaceOfferRequestType"/>
	<xs:complexType name="PlaceOfferRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables the requesting user to submit a bid (make an offer) on the
				item listing specified in ItemID. For competitive-bidding listings
				(Chinese and Dutch auctions), makes a bid. For fixed-price listings
				(Basic Fixed-Price and eBay Stores Inventory listings), purchases
				the item.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables the requesting user to submit a bid (make an offer) on the
						item listing specified in ItemID.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Offer" type="ns:OfferType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the type of offer being made. If the item is a
								competitive-bidding listing, the offer is a bid. If the item is a
								fixed-price listing, then the offer purchases the item. If the item is a
								competitive-bidding listing and the offer is of type with an active,
								unexercised Buy It Now option, then the offer can either purchase the
								item or be a bid. See the schema documentation for OfferType for deatils
								on its properties and their meanings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>PlaceOffer</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID that identifies the item listing for which the offer is
								being submitted.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>PlaceOffer</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BlockOnWarning" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(in) If a warning message exists and BlockOnWarning is true,
								the warning message is returned and the bid is blocked. If no warning message
								exists and BlockOnWarning is true, the bid is placed. If BlockOnWarning
								is false, the bid is placed, regardless of warning.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>PlaceOffer</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: PlaceOffer -->
	<xs:element name="PlaceOfferResponse" type="ns:PlaceOfferResponseType"/>
	<xs:complexType name="PlaceOfferResponseType">
		<xs:annotation>
			<xs:documentation> 
				The PlaceOffer result set provides feedback on the success and result
				of the offer made.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="SellingStatus" type="ns:SellingStatusType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the current bidding/purchase state of the item listing, as of
								the offer extended using PlaceOffer. See the schema documentation for
								the SellingStatus object, the properties of which contain such
								post-offer information as the current high bidder, the current price for
								the item, and the bid increment.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>PlaceOffer</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RelistItem -->
	<xs:element name="RelistItemRequest" type="ns:RelistItemRequestType"/>
	<xs:complexType name="RelistItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to take a single item (or a single multi-item
				listing) that ended without bidders or buyers and re-list it on a
				specified eBay site. The listing may be re-listed with the same item
				properties as the original or the seller may change a number of the
				item's defining properties at re-listing time. The new listing will
				have a different item ID than the original one. RelistItem re-lists a
				single item (or a single multi-item listing) that has already ended.
				To re-list multiple items (multiple listings) that have ended,
				execute RelistItem once for each ended listing.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to take a single item (or a single multi-item
						listing) that ended without bidders or buyers and re-list it on a
						specified eBay site.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements hold the values for item properties that change for the
								item re-list. Item is a required input. At a minimum, the Item.ItemID
								property must be set to the ID of the listing being re-listed (a
								listing that ended in the past 90 days). By default, the new listing's
								Item object properties are the same as those of the original (ended)
								listing. By setting a new value in the Item object, the new listing
								uses the new value rather than the corresponding value from the old
								listing.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModifiedFields" type="ns:ModifiedFieldType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								In release 439 and later, ModifiedFields is no longer required to change
								field values, but it is still supported for backward compatibility.
								It is strongly recommended that you do not use ModifiedFields in this call.
								See the eBay Web Services Guide for information about the DeletedField tag and for
								rules and guidelines for changing values when relisting items.
								ModifiedFields contains an array of item property changes.
								Each element in the array indicates a first
								level property in the Item object (specified in the Item property) that is
								changing in the re-list. Item properties not specified in ModifiedFields are
								not changed in the item re-list, even if a new value is specified in the
								property in the Item object. Properties not specified retain the same value
								as is present in the ended item listing being re-listed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
									<TagStatus>Deprecated</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DeletedField" type="xs:string" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Specifies the name of the field to delete from a listing.
								See the eBay Web Services guide for rules on deleting values when relisting items.
								Also see the relevant field descriptions to determine when to use DeletedField (and potential consequences).
								The request can contain zero, one, or many instances of DeletedField (one for each field to be deleted).
								DeletedField accepts the following path names, which delete the corresponding nodes:&lt;br&gt;&lt;br&gt;
								<!-- Item.ApplicationData (coming soon)&lt;br&gt; -->
								Item.AttributeSetArray&lt;br&gt;
								<!-- Item.BuyItNowPrice (coming soon)&lt;br&gt; -->
								Item.Charity&lt;br&gt;
								Item.DigitalDeliveryDetails&lt;br&gt;
								Item.ListingDesigner.LayoutID&lt;br&gt;
								Item.ListingDesigner.ThemeID&lt;br&gt;
								Item.ListingEnhancement[Value]&lt;br&gt;
								Item.PayPalEmailAddress&lt;br&gt;
								Item.PictureDetails.GalleryURL&lt;br&gt;
								Item.PictureDetails.PictureURL&lt;br&gt;
								Item.ProductListingDetails&lt;br&gt;
								Item.ProximitySearchDetails.PostalCode&lt;br&gt;
								<!-- Item.ReservePrice (coming soon)&lt;br&gt; -->
								Item.SecondaryCategory&lt;br&gt;
								Item.ShippingDetails.PaymentInstructions&lt;br&gt;
								Item.SKU&lt;br&gt;
								Item.SubTitle&lt;br&gt;&lt;br&gt;
								These values are case-sensitive. Use values that match the case of the schema element names
								(Item.PictureDetails.GalleryURL) or make the initial letter of each field name lowercase (item.pictureDetails.galleryURL).
								However, do not change the case of letters in the middle of a field name.
								For example, item.picturedetails.galleryUrl is not allowed.&lt;br&gt;&lt;br&gt;
								To delete a listing enhancement like Featured, specify the value you are deleting;
								for example, Item.ListingEnhancement[Featured].
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RelistItem -->
	<xs:element name="RelistItemResponse" type="ns:RelistItemResponseType"/>
	<xs:complexType name="RelistItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the item ID and the estimated fees for the re-listed listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique item ID for the new listing.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements contain the estimated listing fees for the new item
								listing. The fees do not include the Final Value Fee (FVF), which cannot
								be determined until an item is sold.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Date and time the new listing became active on the eBay site.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Date and time when the new listing ends. This is the starting time plus
								the listing duration.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the primary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID passed in Item.PrimaryCategory was mapped to a new ID by eBay.
								If the primary category has not changed or it has expired with no replacement,
								CategoryID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category2ID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the secondary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID passed in Item.SecondaryCategory was mapped to a new ID by eBay.
								If the secondary category has not changed or it has expired with no replacement,
								Category2ID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>RelistItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RemoveFromWatchList -->
	<xs:element name="RemoveFromWatchListRequest" type="ns:RemoveFromWatchListRequestType"/>
	<xs:complexType name="RemoveFromWatchListRequestType">
		<xs:annotation>
			<xs:documentation>
				Provides users the ability to remove items from their
				My eBay watch list.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Provides users the ability to remove items from their
						My eBay watch list.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The ID of the item to be removed from the
								watch list. Either ItemID or RemoveAllItems must
								be specified, but NOT both. One or more Item IDs
								can be specified, each in it's own ItemID container.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>RemoveFromWatchList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RemoveAllItems" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								If true, then all the items in the user's
								watch list are removed. Either ItemID or
								RemoveAllItems must be specified, but NOT both.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RemoveFromWatchList</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RemoveFromWatchList -->
	<xs:element name="RemoveFromWatchListResponse" type="ns:RemoveFromWatchListResponseType"/>
	<xs:complexType name="RemoveFromWatchListResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns information about the user's My eBay watch list.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="WatchListCount" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) The current number of items in the user's
								watch list (after those specified in the call
								request have been removed)
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddToWatchList</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="WatchListMaximum" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) The maximum number of items allowed in
								watch lists. Currently this value is the same
								for all sites and all users.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>AddToWatchList</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RespondToBestOffer -->
	<xs:element name="RespondToBestOfferRequest" type="ns:RespondToBestOfferRequestType"/>
	<xs:complexType name="RespondToBestOfferRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables the seller of a Best Offer item to respond
				with Accept or Decline to offers made by bidders.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables the seller of a Best Offer item to respond
						with Accept or Decline to offers made by bidders.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the item for which the BestOffer data is to be returned.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BestOfferID" type="ns:BestOfferIDType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								The ID of a Best Offer for the item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Action" type="ns:BestOfferActionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The action taken on the best offer by the seller (e.g.,
								Accept, Decline, or Counter). Bulk Accept and Bulk 
								Counter are not supported. That is, you cannot accept or 
								counter multiple offers in a single call. You can, 
								however, decline multiple offers in a single call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerResponse" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A comment from the seller to the buyer.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>250</MaxLength>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CounterOfferPrice" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The counter offer price. When Action is set to Counter, 
								you must specify the amount for the counteroffer with 
								CounterOfferPrice. The value of CounterOfferPrice cannot 
								exceed the Buy It Now price for a single quantity item. 
								The value of CounterOfferPrice may exceed the Buy It Now 
								price if the value for CounterOfferQuantity is greater 
								than 1.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CounterOfferQuantity" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The counter offer quantity. When Action is set to 
								Counter you must specify the quantity of items for the 
								counteroffer with CounterOfferQuantity. 
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RespondToBestOffer -->
	<xs:element name="RespondToBestOfferResponse" type="ns:RespondToBestOfferResponseType"/>
	<xs:complexType name="RespondToBestOfferResponseType">
		<xs:annotation>
			<xs:documentation>
				Contains a list of BestOffers that were either accepted or declined.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="RespondToBestOffer" type="ns:BestOfferArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A list of BestOffers that were either accepted or declined.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToBestOffer</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RespondToFeedback -->
	<xs:element name="RespondToFeedbackRequest" type="ns:RespondToFeedbackRequestType"/>
	<xs:complexType name="RespondToFeedbackRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables users to reply to feedback left by the other
				party in the transaction and/or follow up on the
				feedback left for the other party.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables users to reply to feedback left by the other
						party in the transaction and/or follow up on the
						feedback left for the other party.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="FeedbackID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID that uniquely identifies the feedback.
								FeedbackIDs can be retrieved by using
								GetFeedback. Required if ItemID is not
								specified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToFeedback</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique identifier of an item to which the
								feedback is attached. Required if FeedbackID is
								not provided.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>RespondToFeedback</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique identifier for a purchase from an
								eBay Stores Inventory or basic fixed price
								listing. If TransactionID is specified, ItemID
								must also be specified.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>RespondToFeedback</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TargetUserID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								User who left the feedback that is being
								replied to or followed up on.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ResponseType" type="ns:FeedbackResponseCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether the response is a reply
								or a follow-up.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ResponseText" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Textual comment that the user who is
								subject of feedback may leave in response or
								rebuttal to the feedback. Alternatively, when
								the  ResponseType is FollowUp, this value
								contains the text of the follow-up comment. Max
								length is 125 for the Taiwan site.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>80</MaxLength>
								<CallInfo>
									<CallName>RespondToFeedback</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RespondToFeedback -->
	<xs:element name="RespondToFeedbackResponse" type="ns:RespondToFeedbackResponseType"/>
	<xs:complexType name="RespondToFeedbackResponseType">
		<xs:annotation>
			<xs:documentation>
				Indicates the success or failure of the attempt to reply
				to feedback that has been left for a user, or to post a
				follow-up comment to a feedback comment a user has left
				for someone else.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RespondToWantItNowPost -->
	<xs:element name="RespondToWantItNowPostRequest" type="ns:RespondToWantItNowPostRequestType"/>
	<xs:complexType name="RespondToWantItNowPostRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to respond to a Want It Now post with an item listed on the eBay
				site.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to respond to a Want It Now post with an item listed on the eBay
						site.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier of an item listed on the eBay site.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>RespondToWantItNowPost</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PostID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier of a Want It Now post on the eBay site.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>RespondToWantItNowPost</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: RespondToWantItNowPost -->
	<xs:element name="RespondToWantItNowPostResponse" type="ns:RespondToWantItNowPostResponseType"/>
	<xs:complexType name="RespondToWantItNowPostResponseType">
		<xs:annotation>
			<xs:documentation>
				Indicates the success or failure of the attempt to respond to a Want It Now post.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType" />
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseCheckoutStatus -->
	<xs:element name="ReviseCheckoutStatusRequest" type="ns:ReviseCheckoutStatusRequestType"/>
	<xs:complexType name="ReviseCheckoutStatusRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to update the payment status of an item.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to update the payment status of an item.
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Third Party Checkout</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ThirdPartyCheckout</URL>
				</SeeLink>
				<SeeLink>
					<Title>Checkout</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=Checkout</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique ID for the item associated with the checkout. A transaction is
								uniquely identified by one of two means: (a) You provide a TransactionID
								and ItemID. (This is the preferred approach.), OR, (b) You provide a
								BuyerID and ItemID and eBay identifies only one transaction for that
								combination (an error is returned if there are multiple transactions for
								that combination). Note: If all three are provided (that is, BuyerID,
								ItemID and TransactionID), BuyerID is ignored.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique ID for the transaction associated with the checkout. For Chinese
								auctions, the value passed in the TransactionID argument must be 0 or the
								call will fail with an error. For all other auction types, TransactionID
								accepts the actual, nonzero transaction ID. Call GetItemTransactionsCall
								or GetSellerTransactionsCall to determine the correct transaction ID. A
								transaction is uniquely identified by one of two means: (a) You provide a
								TransactionID and ItemID. (This is the preferred approach.), OR, (b) You
								provide a BuyerID and ItemID and eBay identifies only one transaction for
								that combination (an error is returned if there are multiple transactions
								for that combination). Note: If all three are provided (that is, BuyerID,
								ItemID and TransactionID), BuyerID is ignored.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique ID for a multi-item order. If specified, ItemID and
								TransactionID are ignored if specified in the same call.
								Changes to the checkout status are applied to the specified
								order as a whole (and thus the child transactions
								associated with the order).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AmountPaid" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The amount paid by the buyer. For an eBay Stores item, the value passed in
								AmountPaid is the transaction/item price. For a US eBay Motors item,
								AmountPaid is the total amount paid by the buyer for the deposit.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentMethodUsed" type="ns:BuyerPaymentMethodCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Payment method used by the buyer.
								Required if CheckoutStatus is Complete.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CheckoutStatus" type="ns:CompleteStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The current status of the checkout process for the transaction.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingService" type="xs:token" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The shipping service selected by the buyer from among the shipping
								services offered by the seller (such as UPS Ground). For a list of valid
								values that you can cache for future use, call GeteBayDetails with
								DetailName set to ShippingServiceDetails.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingIncludedInTax" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An indicator of whether shipping costs were included in the
								taxable amount. For Third-Party Checkout applications.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
								<Default>false</Default>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CheckoutMethod" type="ns:CheckoutMethodCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Not supported.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="InsuranceType" type="ns:InsuranceSelectedCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The insurance option selected by the buyer.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentStatus" type="ns:RCSPaymentStatusCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Not supported.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AdjustmentAmount" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Discount or charge agreed to by the buyer and seller. A positive value
								indicates that the amount is an extra charge being paid to the seller by
								the buyer. A negative value indicates that the amount is a discount given
								to the buyer by the seller.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingAddress" type="ns:AddressType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
							  For internal use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BuyerID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								eBay ID for the buyer in the transaction being revised. A transaction is
								uniquely identified by one of two means: (a) You provide a TransactionID
								and ItemID. (This is the preferred approach.), OR, (b) You provide a
								BuyerID and ItemID and eBay identifies only one transaction for that
								combination (an error is returned if there are multiple transactions for
								that combination). Note: If all three are provided (that is, BuyerID,
								ItemID and TransactionID), BuyerID is ignored.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingInsuranceCost" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Amount of money paid for insurance. For Third Party Checkout
								applications.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SalesTax" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Amount of money paid for sales tax. For Third-Party Checkout
								applications.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingCost" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Amount of money paid for shipping. For Third-party Checkout
								applications.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EncryptedID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Not supported.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>20</MaxLength>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalTransaction" type="ns:ExternalTransactionType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Not supported.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="MultipleSellerPaymentID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Not supported.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseCheckoutStatus</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseCheckoutStatus -->
	<xs:element name="ReviseCheckoutStatusResponse" type="ns:ReviseCheckoutStatusResponseType"/>
	<xs:complexType name="ReviseCheckoutStatusResponseType">
		<xs:annotation>
			<xs:documentation>
      	Indicates success or failure of the attempt to revise the listing's checkout status.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseItem -->
	<xs:element name="ReviseItemRequest" type="ns:ReviseItemRequestType"/>
	<xs:complexType name="ReviseItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to make changes to the definition of an active item
				listing.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to change the properties of a
						currently active listing. Inputs are the item ID of
						the ended item being re-listed and any properties
						that are being changed for the revision.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Required. Child elements hold the values for properties that are changing.
								The Item.ItemID property must always be set to the ID of the item listing being
								changed. Set values in the Item object only for those properties that are
								changing. Use DeletedField to remove a property.
				  			Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModifiedFields" type="ns:ModifiedFieldType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								In release 439 and later, ModifiedFields is no longer required to change
								field values, but it is still supported for backward compatibility.
								It is strongly recommended that you do not use ModifiedFields in this call.
								See the eBay Web Services Guide for information about the DeletedField tag and for
								rules and guidelines for changing values when revising items.
								ModifiedFields contains an array of item property changes. Each element in the array indicates a
								first level property in the Item object (specified in the Item property)
								that is changing in the revision. Item properties not specified in
								ModifiedFields are not changed in the item revision - even if a new value
								is specified in the property in the Item object. Properties not specified
								retain the same value as is present in the active item listing being
								revised. To remove a property from the item, specify it as changed
								in ModifiedFields, but do not specify a value in Item.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
									<TagStatus>Deprecated</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DeletedField" type="xs:string" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Specifies the name of a field to delete from a listing.
								You cannot delete required fields from a listing.&lt;br&gt;&lt;br&gt;
								Some fields are optional when you first list an item (e.g., ListingEnhancement),
								but once they are set they cannot be deleted when you revise an item.
								Some optional fields cannot be deleted if the item has bids and/or ends within 12 hours.
								Some optional fields cannot be deleted if other fields depend on them.
								For example, if GalleryType was already set for the item you are revising,
								you cannot remove it. Therefore, you still need to include at least one picture URL, a gallery URL,
								or a catalog stock photo in your revised listing.
								See the eBay Web Services guide for rules on removing values when revising items.
								Also see the relevant field descriptions for details on when to use DeletedField
								(and potential consequences).&lt;br&gt;&lt;br&gt;
								The request can contain zero, one, or many instances of DeletedField (one for each field to be deleted).
								DeletedField accepts the following path names, which delete the corresponding nodes:&lt;br&gt;&lt;br&gt;
								<!-- Item.ApplicationData (coming soon)&lt;br&gt; -->
								Item.AttributeSetArray&lt;br&gt;
								<!-- Item.BuyItNowPrice (coming soon)&lt;br&gt; -->
								Item.DigitalDeliveryDetails&lt;br&gt;
								Item.ListingDesigner.LayoutID&lt;br&gt;
								Item.ListingDesigner.ThemeID&lt;br&gt;
								Item.PayPalEmailAddress&lt;br&gt;
								Item.PictureDetails.GalleryURL&lt;br&gt;
								Item.PictureDetails.PictureURL&lt;br&gt;
								Item.PostalCode&lt;br&gt;
								Item.ProductListingDetails&lt;br&gt;
								Item.ProximitySearchDetails.PostalCode&lt;br&gt;
								<!-- Item.ReservePrice (coming soon)&lt;br&gt; -->
								Item.ShippingDetails.PaymentInstructions&lt;br&gt;
								Item.SKU&lt;br&gt;&lt;br&gt;
								These values are case-sensitive. Use values that match the case of the schema element names
								(Item.PictureDetails.GalleryURL) or make the initial letter of each field name lowercase (item.pictureDetails.galleryURL).
								However, do not change the case of letters in the middle of a field name.
								For example, item.picturedetails.galleryUrl is not allowed.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseItem -->
	<xs:element name="ReviseItemResponse" type="ns:ReviseItemResponseType"/>
	<xs:complexType name="ReviseItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the item ID and the estimated fees for the revised listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Item ID that uniquely identifies the item listing that was revised.
								Provided for confirmation purposes. The value returned should be the
								same as the item ID specified in the ItemID property of the Item object
								specified as input for the call.
								Also applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Starting date and time for the new listing.
								Also returned for Half.com (for Half.com, the start time is
								always the time the item was listed).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Date and time when the new listing ends. This is the starting time
								plus the listing duration.
								Also returned for Half.com, but for Half.com the actual end time is GTC
								(not the end time returned in the response).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements contain the estimated listing fees for the revised item
								listing. The fees do not include the Final Value Fee (FVF), which cannot
								be determined until an item is sold. Revising an item does not itself
								incur a fee. However, certain item properties are fee-based and result
								in the return of fees in the call's response.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the primary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID passed in Item.PrimaryCategory was mapped to a new ID by eBay.
								If the primary category has not changed or it has expired with no replacement,
								CategoryID does not return a value.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category2ID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the secondary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID passed in Item.SecondaryCategory was mapped to a new ID by eBay.
								If the secondary category has not changed or it has expired with no replacement,
								Category2ID does not return a value.
								Not applicable to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>ReviseItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseLiveAuctionItem -->
	<xs:element name="ReviseLiveAuctionItemRequest" type="ns:ReviseLiveAuctionItemRequestType"/>
	<xs:complexType name="ReviseLiveAuctionItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to make changes to the definition of an active item
				listing that listed for the Live Auction.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables an eBay Live Auctions seller to modify a
						single lot item on the eBay Live Auctions site.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Required. Child elements hold the values for properties that are changing.
								The Item.ID property must always be set to the ID of the item listing being
								changed. Set values in the Item object only for those properties that are
								changing. To remove a property, do not give it a value in Item, but
								specify it as changed in ModifiedFields. Each first-level property
								that has a changed value must be listed in the ModifiedFields property.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseLiveAuctionItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ModifiedFields" type="ns:ModifiedFieldType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Array of item property changes. Each element in the array indicates a
								first level property in the Item object (specified in the Item property)
								that is changing in the revision. Item properties not specified in
								ModifiedFields are not changed in the item revision - even if a new value
								is specified in the property in the Item object. Properties not specified
								retain the same value as is present in the active item listing being
								revised. To remove a property from the item, specify it as changed
								in ModifiedFields, but do not specify a value in Item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseLiveAuctionItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DeletedField" type="xs:string" minOccurs="0" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation>
							Reserved for future use.
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>ReviseLiveAuctionItem</CallName>
								<RequiredInput>No</RequiredInput>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseLiveAuctionItem -->
	<xs:element name="ReviseLiveAuctionItemResponse" type="ns:ReviseLiveAuctionItemResponseType"/>
	<xs:complexType name="ReviseLiveAuctionItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the item ID and the estimated fees for the revised listing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Item ID that uniquely identifies the item listing that was revised.
								Provided for confirmation purposes. The value returned should be the
								same as the item ID specified in the ItemID property of the Item object
								specified as input for the call.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>ReviseLiveAuctionItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements contain the estimated listing fees for the revised item
								listing. The fees do not include the Final Value Fee (FVF), which cannot
								be determined until an item is sold. Revising an item does not itself
								incur a fee. However, certain item properties are fee-based and result
								in the return of fees in the call's response.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseLiveAuctionItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the primary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID passed in Item.PrimaryCategory was mapped to a new ID by eBay.
								If the primary category has not changed or it has expired with no replacement,
								CategoryID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>ReviseLiveAuctionItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category2ID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the secondary category in which the item was listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID passed in Item.SecondaryCategory was mapped to a new ID by eBay.
								If the secondary category has not changed or it has expired with no replacement,
								Category2ID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>ReviseLiveAuctionItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseMyMessages -->
	<xs:element name="ReviseMyMessagesRequest" type="ns:ReviseMyMessagesRequestType"/>
	<xs:complexType name="ReviseMyMessagesRequestType">
		<xs:annotation>
			<xs:documentation>
				Sets the read state for messages and alerts, the flagged state of messages, and moves
				alerts and messages into and out of folders.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Sets the read state for messages and alerts, the flagged state of messages, and moves
						alerts and messages into and out of folders.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="MessageIDs" type="ns:MyMessagesMessageIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of up to 10 MessageID values. Either AlertIDs, MessageIDs,
								or both must be included in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="AlertIDs" type="ns:MyMessagesAlertIDArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains a list of up to 10 AlertID values. Either AlertIDs, MessageIDs,
								or both must be included in the request
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Read" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Changes the read states of all alerts and
								messages specified in a request by their AlertID
								or MessageID values. At least one of Read,
								Flagged, or FolderID must be specified in the
								request. Note that alerts and messages retrieved
								with the API are not automatically marked Read,
								and must be marked Read with this call.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Flagged" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Changes the flagged states of all messages specified in a request
								by their MessageID values. At least one of Read, Flagged, or FolderID
								 must be specified in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FolderID" type="xs:long" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								An ID that uniquely identifies the My Messages folder to move
								alerts and messages into. At least one of Read, Flagged, or FolderID
								 must be specified in the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessages</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseMyMessages -->
	<xs:element name="ReviseMyMessagesResponse" type="ns:ReviseMyMessagesResponseType"/>
	<xs:complexType name="ReviseMyMessagesResponseType">
		<xs:annotation>
			<xs:documentation>
				The response to ReviseMyMessagesRequestType. If the request was successful, 
				ReviseMyMessages returns nothing.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseMyMessagesFolders -->
	<xs:element name="ReviseMyMessagesFoldersRequest" type="ns:ReviseMyMessagesFoldersRequestType"/>
	<xs:complexType name="ReviseMyMessagesFoldersRequestType">
		<xs:annotation>
			<xs:documentation>
				Renames, removes, or restores specified My Messages folders for
				a given user.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Renames, removes, or restores specified My Messages folders
						for a given user.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Operation" type="ns:MyMessagesFolderOperationCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates the type of operation to perform on a
								specified My Messages folder. Operations include
								renaming, removing, and restoring folders. Operations
								cannot be performed on the Inbox and Sent folders.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessagesFolders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FolderID" type="xs:long" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								An ID that uniquely identifies the My Messages
								folder to perform the operation on. Retrieve FolderIDs
								by calling GetMyMessages with a DetailLevel of
								ReturnSummary. Inbox is FolderID = 0, and Sent is
								FolderID = 1.
								</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessagesFolders</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="FolderName" type="xs:string" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
							The name of a specified My Messages folder. Depending
							on the specified Operation, the value is an existing
							folder name or a new folder name. Retrieve existing
							FolderNames by calling GetMyMessages with a DetailLevel
							of ReturnSummary. Inbox is FolderID = 0, and Sent is
							FolderID = 1.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ReviseMyMessagesFolders</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ReviseMyMessagesFolders -->
	<xs:element name="ReviseMyMessagesFoldersResponse" type="ns:ReviseMyMessagesFoldersResponseType"/>
	<xs:complexType name="ReviseMyMessagesFoldersResponseType">
		<xs:complexContent>
		<xs:annotation>
			<xs:documentation>
				The response to ReviseMyMessagesFoldersRequestType. If the request was successful, 
				ReviseMyMessagesFolders returns nothing.
			</xs:documentation>
		</xs:annotation>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SellerReverseDispute -->
	<xs:element name="SellerReverseDisputeRequest" type="ns:SellerReverseDisputeRequestType"/>
	<xs:complexType name="SellerReverseDisputeRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to reverse an Unpaid Item dispute that has been
				closed, for example, if buyer and seller reach an agreement. The
				seller's Final Value Fee credit and the buyer's strike are both
				reversed.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to reverse an Unpaid Item dispute that has been
						closed, for example, if buyer and seller reach an agreement.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="DisputeID" type="ns:DisputeIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The unique identifier of the dispute that was returned when the dispute was created.
								The dispute must be an Unpaid Item dispute that the seller opened. Required.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SellerReverseDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DisputeResolutionReason" type="ns:DisputeResolutionReasonCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The reason the dispute is being reversed. Required.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SellerReverseDispute</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SellerReverseDispute -->
	<xs:element name="SellerReverseDisputeResponse" type="ns:SellerReverseDisputeResponseType"/>
	<xs:complexType name="SellerReverseDisputeResponseType">
		<xs:annotation>
			<xs:documentation>
            		 Returned after calling SellerReverseDisputeRequest. Contains the status
            		 of the call and any errors or warnings.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SendInvoice -->
	<xs:element name="SendInvoiceRequest" type="ns:SendInvoiceRequestType"/>
	<xs:complexType name="SendInvoiceRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables a seller to send an invoice to buyer for a transaction.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to send an invoice to a buyer for a transaction.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Item ID. If OrderID is not provided, both ItemID and
								TransactionID must be provided.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="TransactionID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID for the transaction with which the item was sold.
								If OrderID is not provided, both ItemID and
								TransactionID must be provided.
								For Chinese auctions, the value passed in the TransactionId
								argument must be 0 or the call will fail with an error.
								Call GetItemTransactions or GetSellerTransactions to
								determine the correct transaction ID.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="OrderID" type="ns:OrderIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Unique ID for a multi-item order. Either this OrderID must
								be specified or ItemID plus TransactionID must be specified.
								If OrderID is specified, ItemID and
								TransactionID are ignored if present in the same request. Changes to the
								checkout status are applied to the specified order as a whole
								(and thus to the child transactions associated with the order).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="InternationalShippingServiceOptions" type="ns:InternationalShippingServiceOptionsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Shipping costs and options related to an international
								shipping service. When used as input, if one is provided,
								at least one domestic ShippingService must be provided.&lt;br&gt;
								&lt;br&gt;
								Not applicable to invoices for digital listings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ShippingServiceOptions" type="ns:ShippingServiceOptionsType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Indicates the shipping service that would be used to ship the item (such
								as UPS Ground). Seller can provide up to three. Shipping insurance cost
								should be identical for all domestic services.&lt;br&gt;
								&lt;br&gt;
								Not applicable to invoices for digital listings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SalesTax" type="ns:SalesTaxType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The details of the sales tax added to the invoice.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="InsuranceOption" type="ns:InsuranceOptionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether insurance fee is required. An InsuranceOption value of
								IncludedInShippingHandling cannot be used if the item will use calculated
								shipping. Some shipping carriers automatically include shipping insurance
								for qualifying items.&lt;br&gt;
								&lt;br&gt;
								Not applicable to invoices for digital listings.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
								<SeeLink>
									<Title>Getting Shipping Cost Information</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="InsuranceFee" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>Insurance cost, as set by seller, if ShippingType = 1.
								Specify if InsuranceOption is optional or required. Must
								be greater than zero value if a value of Optional or Required is passed in
								InsuranceOption. Value specified should be the total cost of insuring the
								item.&lt;br&gt;
								&lt;br&gt;
								Not applicable to invoices for digital listings.
							</xs:documentation>
							<xs:appinfo>
								<Default>0.0</Default>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
								<SeeLink>
									<Title>Getting Shipping Cost Information</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PaymentMethods" type="ns:BuyerPaymentMethodCodeType" minOccurs="0"  maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Optional ability for the seller to add certain payment methods on
								transaction if they were not originally specified on the item.  Valid
								values are PayPal in the US, MoneyXferAcceptedInCheckout (CIP+) in
								Germany, and Escrow in China
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PayPalEmailAddress" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Provide PayPal email address if the payment method added is PayPal.
								For digital listings, this must be an email address associated with
								a verified PayPal Premier or Business account.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CheckoutInstructions" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								 Seller's Payment instructions/message to the buyer and return policy.
								 Default is null.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>500</MaxLength>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EmailCopyToSeller" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether the seller wishes to be copied on the invoice email that
								will be sent to the buyer. Default will be true.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SendInvoice</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SendInvoice -->
	<xs:element name="SendInvoiceResponse" type="ns:SendInvoiceResponseType"/>
	<xs:complexType name="SendInvoiceResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the status.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetNotificationPreferences -->
	<xs:element name="SetNotificationPreferencesRequest"	type="ns:SetNotificationPreferencesRequestType"/>
	<xs:complexType name="SetNotificationPreferencesRequestType">
		<xs:annotation>
			<xs:documentation>
				Manages a user's notification preferences. These preferences can be at the application
				level, or at the user level.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Manages a user's notification preferences. Part of
						eBay Platform Notifications, which
						can be used to alert Production-certified
						applications when certain events occur on the eBay
						site.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ApplicationDeliveryPreferences" type="ns:ApplicationDeliveryPreferencesType" minOccurs="0">
						<xs:annotation>
		 					<xs:documentation>
								Specifies application-based event preferences that have been enabled.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetNotificationPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserDeliveryPreferenceArray" type="ns:NotificationEnableArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Array of NotificationEventEnableTypes. Each NotificationEventEnableType
								contains an EventSetting and an EventType.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetNotificationPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="UserData" type="ns:NotificationUserDataType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies user data for notification settings such as mobile phone number.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetNotificationPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EventProperty" type="ns:NotificationEventPropertyType" minOccurs="0" maxOccurs="unbounded">
						<xs:annotation>
							<xs:documentation>
								Characteristics or details of an event such as type, name and value.
								Currently can only be set for wireless applications.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetNotificationPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetNotificationPreferences -->
	<xs:element name="SetNotificationPreferencesResponse"  type="ns:SetNotificationPreferencesResponseType"/>
	<xs:complexType name="SetNotificationPreferencesResponseType">
		<xs:annotation>
			<xs:documentation>
				(out) Returned after a call to SetNotificationPreferences to indicate that the call succeeded.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetPictureManagerDetails -->
	<xs:element name="SetPictureManagerDetailsRequest" type="ns:SetPictureManagerDetailsRequestType"/>
	<xs:complexType name="SetPictureManagerDetailsRequestType">
		<xs:annotation>
			<xs:documentation>
	      Creates, updates, or deletes Picture Manager account settings, folders, or pictures.
	    </xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Creates, updates, or deletes Picture Manager account settings, folders, or pictures.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="PictureManagerDetails" type="ns:PictureManagerDetailsType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the setting or folder to create, update, or delete, or the picture to update. You cannot upload or delete pictures using SetPictureManagerDetails; you must use the eBay site.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetPictureManagerDetails</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Action" type="ns:PictureManagerActionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the action to take on the setting, folder, or picture.
								The values Add and Delete apply only to folders.
					   	</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetPictureManagerDetails</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetPictureManagerDetails -->
	<xs:element name="SetPictureManagerDetailsResponse" type="ns:SetPictureManagerDetailsResponseType"/>
	<xs:complexType name="SetPictureManagerDetailsResponseType">
		<xs:annotation>
			<xs:documentation>
	     Returns the status of an action on a setting, folder, or picture in a Picture Manager account.
	    </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetPromotionRules -->
	<xs:element name="SetPromotionRulesRequest" type="ns:SetPromotionRulesRequestType"/>
	<xs:complexType name="SetPromotionRulesRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests to define cross-promotion rules for an item
				or store category.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests to define cross-promotion rules for an item
						or store category.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="OperationType" type="ns:OperationTypeCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether the update is for item rules or default rules for the promotion
								type. Allowed values are ItemRules or ReplaceAllDefaultRules. Required when
								setting default rules.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetPromotionRules</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="PromotionRuleArray" type="ns:PromotionRuleArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies a list of cross-promotion rules to set.
								Each rule defines a referring item or store category
								and the cross-promoted items or store categories.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetPromotionRules</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetPromotionRules -->
	<xs:element name="SetPromotionRulesResponse" type="ns:SetPromotionRulesResponseType"/>
	<xs:complexType name="SetPromotionRulesResponseType">
		<xs:annotation>
			<xs:documentation>
          	  Returned after calling SetPromotionRulesRequest to indicate
			  whether the rules have been set successfully.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetReturnURL -->
	<xs:element name="SetReturnURLRequest" type="ns:SetReturnURLRequestType"/>
	<xs:complexType name="SetReturnURLRequestType">
		<xs:annotation>
			<xs:documentation>
				Configures your application's Auth n Auth preferences and other data, such as the
				URLs that eBay should redirect users to after they complete the authentication and
				authorization process. This call must be authenticated using the application's
				username and password (not an authentication token).
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Configures your application's authentication and authorization preferences and
						other data, such as the URLs that eBay should redirect users to after they
						complete the authentication and authorization process.
					</Summary>
				</Overview>
				<SeeLink>
					<Title>Authentication &amp; Authorization</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="AuthenticationEntry" type="ns:AuthenticationEntryType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The authentication preferences and other data that you are
								adding, deleting, or modifying.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetReturnURL</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
								<SeeLink>
									<Title>Authentication &amp; Authorization</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ApplicationDisplayName" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Sets an application display name for the eBay sign-in page.
								Need not be set with every call. Optional.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetReturnURL</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
								<SeeLink>
									<Title>Authentication &amp; Authorization</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Action" type="ns:ModifyActionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether the authentication entry is being added, deleted, or
								modified.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetReturnURL</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
								<SeeLink>
									<Title>Authentication &amp; Authorization</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
								</SeeLink>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetReturnURL -->
	<xs:element name="SetReturnURLResponse" type="ns:SetReturnURLResponseType"/>
	<xs:complexType name="SetReturnURLResponseType">
		<xs:annotation>
			<xs:documentation>
				Confirms whether your application's authentication preferences and other details
				were configured successfully.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStore -->
	<xs:element name="SetStoreRequest" type="ns:SetStoreRequestType"/>
	<xs:complexType name="SetStoreRequestType">
		<xs:annotation>
			<xs:documentation>
				Contains the Store configuration that is being set by this call.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Contains the Store configuration that is being set by this call.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Store" type="ns:StoreType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
					      Specifies the Store configuration that is being set for the user.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStore</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStore -->
	<xs:element name="SetStoreResponse" type="ns:SetStoreResponseType"/>
	<xs:complexType name="SetStoreResponseType">
	  <xs:annotation>
	    <xs:documentation>
	      Returned after calling SetStoreRequest. This serves as confirmation that
        the Store configuration was successfully submitted.
	    </xs:documentation>
	  </xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStoreCategories -->
	<xs:element name="SetStoreCategoriesRequest" type="ns:SetStoreCategoriesRequestType"/>
	<xs:complexType name="SetStoreCategoriesRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests changes to the category structure for a store. Use this
				call to add, delete, move, or rename a list of categories.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests changes to the category structure for a store.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Action" type="ns:StoreCategoryUpdateActionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the type of action (Add, Move, Delete, or Rename) to carry out
								for the specified categories.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCategories</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemDestinationCategoryID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Items can only be contained within child categories. A parent category
								cannot contain items. If adding, moving, or deleting categories displaces
								items, you must specify a destination child category under which the
								displaced items will be moved. The destination category must have no
								child categories.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCategories</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="DestinationParentCategoryID" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								When adding or moving store categories, specifies the category under
								which the listed categories will be located. To add or move categories to
								the top level, set the value to -999.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCategories</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element  name="StoreCategories"  type="ns:StoreCustomCategoryArrayType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains information for specifying the store categories being acted on.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCategories</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStoreCategories -->
	<xs:element name="SetStoreCategoriesResponse" type="ns:SetStoreCategoriesResponseType"/>
	<xs:complexType name="SetStoreCategoriesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the status of the processing progress for changes to the category 
				structure for a store.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="TaskID" type="xs:long" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The task ID associated with the category structure change request. If the 
								SetStoreCategories call is process synchronously, the task ID is 0. If the 
								category structure changes affect many listings, the changes will be 
								processed asynchronously and the task ID will be a positive number. Use 
								the task ID with GetStoreCategoryUpdateStatus to monitor the status of 
								asynchronously processed changes.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCategories</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Status" type="ns:TaskStatusCodeType" minOccurs="0">  <!-- Done/Queued/InProgress/Failed -->
						<xs:annotation>
							<xs:documentation>
								When a category structure change is processed synchronously, the status 
								is returned as Complete or Failed. For asynchronously processed changes, 
								the status is reported as Pending. Use GetStoreCategoryUpdateStatus to 
								monitor the status of asynchronously processed changes.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCategories</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStoreCustomPage -->
	<xs:element name="SetStoreCustomPageRequest" type="ns:SetStoreCustomPageRequestType"/>
	<xs:complexType name="SetStoreCustomPageRequestType">
		<xs:annotation>
			<xs:documentation>
	      Sets a Store custom page.
	    </xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
			      Sets a custom page for a user's eBay Store. The
			      page can include static HTML content as well as
			      dynamic content that is added using the special eBay
			      Stores tags.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="CustomPage" type="ns:StoreCustomPageType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
	   				  	The custom page being submitted.
	  					</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCustomPage</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStoreCustomPage -->
	<xs:element name="SetStoreCustomPageResponse" type="ns:SetStoreCustomPageResponseType"/>
	<xs:complexType name="SetStoreCustomPageResponseType">
	  <xs:annotation>
	    <xs:documentation>
	      Returned after calling SetStoreCustomPageRequest. This serves as
	      confirmation that the custom page was successfully submitted.
	    </xs:documentation>
	  </xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="CustomPage" type="ns:StoreCustomPageType" minOccurs="0">
		  			<xs:annotation>
	    				<xs:documentation>
	   				  	The custom page that was submitted.
	  					</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStoreCustomPage</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>				
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStorePreferences -->
	<xs:element name="SetStorePreferencesRequest" type="ns:SetStorePreferencesRequestType"/>
	<xs:complexType name="SetStorePreferencesRequestType">
		<xs:annotation>
			<xs:documentation>
				Contains the Store configuration that is being set by this call.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Sets the preferences for a user's eBay Store. These
						preferences include various seller vacation options.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="StorePreferences" type="ns:StorePreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
					      Specifies the store preferences.
					    </xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetStorePreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetStorePreferences -->
	<xs:element name="SetStorePreferencesResponse" type="ns:SetStorePreferencesResponseType"/>
	<xs:complexType name="SetStorePreferencesResponseType">
		<xs:annotation>
			<xs:documentation>
	      Returned after calling SetStorePreferencesRequest. This serves as confirmation that 
        the Store preferences were successfully submitted.
	    </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetTaxTable -->
	<xs:element name="SetTaxTableRequest" type="ns:SetTaxTableRequestType"/>
	<xs:complexType name="SetTaxTableRequestType">
		<xs:annotation>
			<xs:documentation>
				Sets the tax table for a seller on a given site.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Sets the tax table for a seller on a given site.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="TaxTable" type="ns:TaxTableType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								A container of tax jurisdiction information unique to a user/site combination.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetTaxTable</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetTaxTable -->
	<xs:element name="SetTaxTableResponse" type="ns:SetTaxTableResponseType"/>
	<xs:complexType name="SetTaxTableResponseType">
		<xs:annotation>
			<xs:documentation>
				Response to SetTaxTableRequest.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetUserNotes -->
	<xs:element name="SetUserNotesRequest" type="ns:SetUserNotesRequestType"/>
	<xs:complexType name="SetUserNotesRequestType">
		<xs:annotation>
			<xs:documentation>
				Enables users to add, modify and delete Notes from the items that are being tracked in
				the My eBay All Selling and All Buying areas.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables users to add, modify and delete Notes from the items that are being tracked in
						the My eBay All Selling and All Buying areas.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the item to which the note will be attached.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>SetUserNotes</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Action" type="ns:SetUserNotesActionCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies whether to add/update the note or delete.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserNotes</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="NoteText" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Text of the note. Maximum 250 characters.
								Required only if the Action is AddOrUpdate.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>250</MaxLength>
								<CallInfo>
									<CallName>SetUserNotes</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetUserNotes -->
	<xs:element name="SetUserNotesResponse" type="ns:SetUserNotesResponseType"/>
	<xs:complexType name="SetUserNotesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the status of the call.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType"/>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetUserPreferences -->
	<xs:element name="SetUserPreferencesRequest" type="ns:SetUserPreferencesRequestType"/>
	<xs:complexType name="SetUserPreferencesRequestType">
		<xs:annotation>
			<xs:documentation>
				Sets the user's preferences to those specified in the request. As
				a general rule, once you set a preference,  GetUserPreferences
				and the user's preferences displayed on the eBay Web site should
				reflect the new setting immediately. However, it could take up to
				7 days for the change to have any logical or functional effect.
				For example, if you change your combined payment preferences, it
				could take up to 7 days for eBay to apply the updated combined
				payment settings to your listings. Also, once you set a
				preference, you cannot change its setting again within 7 days.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Sets the user's preferences to those specified in the request.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="BidderNoticePreferences" type="ns:BidderNoticePreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The user's bidder notice preferences to be set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CombinedPaymentPreferences" type="ns:CombinedPaymentPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The user's combined payment preferences to be set.
								When you change these preferences, it can take up to 7 days for the change
								to have any logical or functional effect on eBay. &lt;br&gt;
								&lt;br&gt;
								For the US and Germany sites, combined payment preferences can also affect whether a
								seller is eligible to list on Express.
								A seller needs to allow shoppers to pay by single, combined payments for their purchases.
								A seller is not eligible for Express if they don't allow combined payments.
								Once changes to these preferences take effect on eBay (within 7 days), it can take up to 7 more days for
								existing items to be added to or removed from Express. Thus, it can take up to 14 days (total)
								for combined payment preference changes to affect whether listings appear on Express.
								Also see ExpressPreferences.ExpressSellingPreferences.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CrossPromotionPreferences" type="ns:CrossPromotionPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The user's cross promotion preferences to be set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerPaymentPreferences" type="ns:SellerPaymentPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The user's seller payment preferences to be set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerFavoriteItemPreferences" type="ns:SellerFavoriteItemPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Seller's favorite item preferences to be set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndOfAuctionEmailPreferences" type="ns:EndOfAuctionEmailPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The seller's end of auction email preferences to be set.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="eBxOptInPreference" type="ns:eBxOptInPreferenceType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								TThe seller's Express opt-in preference, which indicates
								whether they want their eligible listings to be included on eBay Express.
								As of release 463, you should use ExpressPreferences instead.
								Only applicable to sellers who are eligible to list on Express.
								Call GetUser to determine the seller's eligibility.
								This flag may be obsolete soon.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
									<TagStatus>ObsoleteSoon</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExpressPreferences" type="ns:ExpressPreferencesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								The seller's Express preferences. Currently used to indicate
								which of the seller's eligible listings to include on Express.
								You can only set these preferences for sellers who are eligible
								to list on Express.
								To determine the seller's eligibility, call GetUser and check the value of SellerInfo.ExpressEligible.
								Once you set Express preferences, you cannot set them again
								(e.g., to change the value) within 7 days.
								Also see CombinedPaymentPreferences, which affect a seller's
								eligibility to list on Express.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>SetUserPreferences</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: SetUserPreferences -->
	<xs:element name="SetUserPreferencesResponse" type="ns:SetUserPreferencesResponseType"/>
	<xs:complexType name="SetUserPreferencesResponseType">
		<xs:annotation>
			<xs:documentation>
				Returned after a call to SetUserPreferences to indicate that the call succeeded.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ValidateTestUserRegistration -->
	<xs:element name="ValidateTestUserRegistrationRequest" type="ns:ValidateTestUserRegistrationRequestType"/>
	<xs:complexType name="ValidateTestUserRegistrationRequestType">
		<xs:annotation>
			<xs:documentation>
				Requests to enable a test user to sell items in the Sandbox environment.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Requests to enable a test user to sell items in the Sandbox environment.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="FeedbackScore" type="xs:int" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Value for the feedback score of a user. If no value is passed in the request,
								or if the value is zero, the feedback score is unchanged. This element is not intended
								for regularly testing feedback because the feedback value can change after the request.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ValidateTestUserRegistration</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="RegistrationDate" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Value for the date and time that a user's registration begins.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ValidateTestUserRegistration</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SubscribeSA" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates if a user subscribes to Seller's Assistant. You cannot
								request to subscribe a user to both Seller's Assistant and
								Seller's Assistant Pro. You cannot request to unsubscribe a user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ValidateTestUserRegistration</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SubscribeSAPro" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates if a user subscribes to Seller's Assistant Pro. You cannot
								request to subscribe a user to both Seller's Assistant and
								Seller's Assistant Pro. You cannot request to unsubscribe a user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ValidateTestUserRegistration</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SubscribeSM" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates if a user subscribes to Selling Manager. You cannot
								request to subscribe a user to both Selling Manager and
								Selling Manager Pro. You cannot request to unsubscribe a user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ValidateTestUserRegistration</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SubscribeSMPro" type="xs:boolean" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Indicates if a user subscribes to Selling Manager Pro. You cannot
								request to subscribe a user to both Selling Manager and
								Selling Manager Pro. You cannot request to unsubscribe a user.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>ValidateTestUserRegistration</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: ValidateTestUserRegistration -->
	<xs:element name="ValidateTestUserRegistrationResponse" type="ns:ValidateTestUserRegistrationResponseType"/>
	<xs:complexType name="ValidateTestUserRegistrationResponseType">
	  <xs:annotation>
	    <xs:documentation>
	      Returned after calling ValidateTestUserRegistrationRequest; confirms a successful
	      call.
	    </xs:documentation>
	  </xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: VerifyAddItem -->
	<xs:element name="VerifyAddItemRequest" type="ns:VerifyAddItemRequestType"/>
	<xs:complexType name="VerifyAddItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Defines a single new item and tests the definition for validity. Behaves exactly
				the same as AddItem (same inputs, same outputs, and same behavior and usage rules),
				but without actually listing the item to an eBay site. Applications can use this call
				to test the definition of an item before actually listing it to eBay with AddItem,
				reducing item listing-related errors.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Enables a seller to specify the properties for a new
						item and submit to eBay without creating a
						listing. This enables the seller to test
						the specified item properties for validity and get
						an estimate of the listing fees before actually
						listing the item. Inputs are the same as for AddItem.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="Item" type="ns:ItemType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ItemType object, the properties of which define the new item listing.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								&lt;b&gt;Deprecated.&lt;/b&gt; This field will be removed from the schema
								in a future release. Recommended usage as of release 439 varies for
								eBay.com listings and Half.com listings.
								&lt;br&gt;&lt;br&gt;
								For eBay.com listings:
								As of release 439, this field can still be passed in, but we recommend
								that you update your applications to use the ExternalProductID field
								defined on the item instead (i.e., Item.ExternalProductID). If you
								specify both Item.ExternalProductID and this field in the same request,
								eBay uses the value in Item.ExternalProductID and ignores the value in
								this field. See Item.ExternalProductID for information on using an
								external ID for eBay.com listings.
								&lt;br&gt;&lt;br&gt;
								For Half.com listings:
								As of release 439, this field is required for Half.com listings.
								Causes Half.com to list the item with Pre-filled Item Information based on
								an ISBN value or other supported external ID, plus other meta-data that
								you specify. See the eBay Web Services guide for information about
								listing to Half.com.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddItem</CallName>
									<RequiredInput>Conditionally</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: VerifyAddItem -->
	<xs:element name="VerifyAddItemResponse" type="ns:VerifyAddItemResponseType"/>
	<xs:complexType name="VerifyAddItemResponseType">
		<xs:annotation>
			<xs:documentation>
				Returns the estimated fees that would be applicable for a new listing
				(were the item actually listed to eBay with AddItem).
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Represents the item ID for the new listing. VerifyAddItem does not
								actually list an item, so 0 is returned instead of a normal item ID.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>VerifyAddItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Fees" type="ns:FeesType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Child elements contain the estimated listing fees for the new item listing.
								The fees do not include the Final Value Fee (FVF), which cannot be determined
								until an item is sold.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CategoryID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the primary category in which the item would be listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID you passed in PrimaryCategory was mapped to a new ID by eBay.
								If the primary category has not changed or it has expired with no replacement,
								CategoryID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>VerifyAddItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Category2ID" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								ID of the secondary category in which the item would be listed.
								Only returned if you set Item.CategoryMappingAllowed to true in the request
								and the ID you passed in SecondaryCategory was mapped to a new ID by eBay.
								If the secondary category has not changed or it has expired with no replacement,
								Category2ID does not return a value.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>10</MaxLength>
								<CallInfo>
									<CallName>VerifyAddItem</CallName>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--  Call: VerifyAddSecondChanceItem -->
	<xs:element name="VerifyAddSecondChanceItemRequest" type="ns:VerifyAddSecondChanceItemRequestType"/>
	<xs:complexType name="VerifyAddSecondChanceItemRequestType">
		<xs:annotation>
			<xs:documentation>
				Emulates the creation of a new Second Chance Offer
				listing for an item to one of that item's non-winning
				bidders.
			</xs:documentation>
			<xs:appinfo>
				<Overview>
					<Summary>
						Tests the input for AddSecondChanceItem, without
						actually creating the second chance offer listing.
						Used for testing the listing of an item
						that will be made for one of the item's non-winning
						bidders.
					</Summary>
				</Overview>
			</xs:appinfo>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractRequestType">
				<xs:sequence>
					<xs:element name="RecipientBidderUserID" type="ns:UserIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the bidder from the original,
								ended listing to whom the seller is extending
								the second chance offer. Specify only one
								RecipientBidderUserID per call. If multiple
								users are specified (each in a
								RecipientBidderUserID node), only the last one
								specified receives the offer.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="BuyItNowPrice" type="ns:AmountType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the amount the offer recipient
								must pay to purchase the item from the second
								chance offer listing. Use only when the original
								item was an eBay Motors (or in some categories
								on U.S. and international sites for high-priced
								items, such as items in many U.S. and Canada
								Business and Industrial categories) and it ended
								unsold because the reserve price was not met.
								Call fails with an error for any other item
								conditions.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="CopyEmailToSeller" type="xs:boolean">
						<xs:annotation>
							<xs:documentation>
									Specifies whether to send a
									copy to the seller of the second chance offer
									notification email that goes to the recipient
									user. With 457, the seller always receives a
									copy of the email, and this tag is ignored as
									input.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
									<TagStatus>Obsolete</TagStatus>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Duration" type="ns:SecondChanceOfferDurationCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
									Specifies the length of time the second
									chance offer listing will be active. The
									recipient bidder has that much time to
									purchase the item or the listing expires.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Specifies the item ID for the original,
								ended listing from which the second chance
								offer item comes. A new ItemID is returned for
								the second chance offer item.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<RequiredInput>Yes</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="Site" type="ns:SiteCodeType" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Reserved for internal or future use.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<NoCalls/>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="SellerMessage" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Message content. Cannot contain HTML,
								asterisks, or quotes. This content is
								included in the second chance offer email sent
								to the recipient, which can be retrieved with
								GetMyMessages.
							</xs:documentation>
							<xs:appinfo>
								<MaxLength>1000</MaxLength>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<RequiredInput>No</RequiredInput>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<!--  Call: VerifyAddSecondChanceItem -->
	<xs:element name="VerifyAddSecondChanceItemResponse" type="ns:VerifyAddSecondChanceItemResponseType"/>
	<xs:complexType name="VerifyAddSecondChanceItemResponseType">
		<xs:annotation>
			<xs:documentation>
				VerifyAddSecondChanceItem request to emulate creation of a new Second Chance Offer for an item to one of
				that item's bidders.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="Fees" type="ns:FeesType"  minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								Contains the listing fees for the new second
								chance offer listing. No fees are actually
								assessed as VerifyAddSecondChanceItem does not actually create the new second chance offer
								listing. Provides an estimate of the fees should
								the offer actually be made using
								AddSecondChanceItem.
								See the documentation on Value-Added Tax.
							</xs:documentation>
							<xs:appinfo>
								<SeeLink>
									<Title>Value-Added Tax (VAT)</Title>
									<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/B2BandVAT-Value-Added_Tax_(VAT).html</URL>
								</SeeLink>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
									Indicates the date and time when the the new
									second chance offer listing became active and
									the recipient user could purchase the item.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
									Indicates the date and time when the second
									chance offer listing expires, at which time
									the listing ends (if the recipient user does
									not purchase the item first).
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<CallName>VerifyAddSecondChanceItem</CallName>
									<Returned>Always</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>


	<!--  
##### from file ../Shared/public/AbstractRequestType.xsd #####

-->
	<xs:complexType name="AbstractRequestType" abstract="true">
		<xs:annotation>
			<xs:documentation>
				Base type definition of the request payload, which can carry any type of payload
				content plus optional versioning information and detail level requirements. All
				concrete request types (e.g., AddItemRequestType) are derived from the abstract
				request type. The naming convention we use for the concrete type names is the name
				of the service (the verb or call name) followed by "RequestType":
				VerbNameRequestType
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DetailLevel" type="ns:DetailLevelCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Detail levels are instructions that define standard subsets of
						data to return for particular data components (e.g., each
						Item, Transaction, or User) within the response payload.
						For example, a particular detail level might cause the
						response to include buyer-related data in every result
						(e.g., for every Item), but no seller-related data.
						Specifying a detail level is like using a
						predefined attribute list in the SELECT clause of an SQL query.
						Use the DetailLevel element to specify the required detail level
						that the client application needs pertaining to the data components
						that are applicable to the request.&lt;br&gt;
						&lt;br&gt;
						The DetailLevelCodeType defines the
						global list of available detail levels for all request types.
						Most request types support certain detail
						levels or none at all. If you pass a detail level that exists
						in the schema but that isn't valid for a particular request,
						eBay ignores it processes the request without it.
						For each request type, see the detail level tables in the
						Input/Output Reference to determine which detail levels are
						applicable and which elements are returned for each applicable
						detail level. (Some detail level tables are still in the
						eBay Web Services guide. They will be moved to the
						Input/Output Reference in a future release.)&lt;br&gt;
						&lt;br&gt;Note that DetailLevel is required input for
						GetMyMessages. &lt;br&gt;
						&lt;br&gt;
						With GetSellerList and other calls that retrieve large data sets,
						please avoid using ReturnAll when possible. For example, if you use
						GetSellerList, use a GranularityLevel or use the
						GetSellerEvents call instead. If you do use ReturnAll with
						GetSellerList, use a small EntriesPerPage value and a short
						EndTimeFrom/EndTimeTo range for better performance.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAttributesCS</CallName>
							<CallName>GetAttributesXSL</CallName>
							<CallName>GetCategories</CallName>
							<CallName>GetCategory2CS</CallName>
							<CallName>GetCategory2FinanceOffer</CallName>
							<CallName>GetCategoryFeatures</CallName>
							<CallName>GetCategoryMappings</CallName>
							<CallName>GetFeedback</CallName>
							<CallName>GetFinanceOffers</CallName>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetMyMessages</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetOrderTransactions</CallName>
							<CallName>GetProductFinder</CallName>
							<CallName>GetProductFinderXSL</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSellerEvents</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetSellerTransactions</CallName>
							<CallName>GetTaxTable</CallName>
							<CallName>GetUser</CallName>
							<CallName>GetUserDisputes</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorLanguage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Use ErrorLanguage to return error strings for the call in a different language
						from the language commonly associated with the site that the requesting user
						is registered with. Specify the standard RFC 3066 language identification tag
						(e.g., en_US).
						&lt;br&gt;
						ID--- country&lt;br&gt;
						----- -----&lt;br&gt;
						de_AT Austria&lt;br&gt;
						de_CH Switzerland&lt;br&gt;
						de_DE Germany &lt;br&gt;
						en_AU Australia &lt;br&gt;
						en_CA Canada &lt;br&gt;
						en_GB United Kingdom&lt;br&gt;
						en_SG Singapore&lt;br&gt;
						en_US United States &lt;br&gt;
						es_ES Spain &lt;br&gt;
						fr_BE Belgium (French)&lt;br&gt;
						fr_FR France &lt;br&gt;
						it_IT Italy &lt;br&gt;
						nl_BE Belgium (Dutch)&lt;br&gt;
						nl_NL Netherlands &lt;br&gt;
						zh_TW Taiwan&lt;br&gt;
						zh_CN China&lt;br&gt;
						en_IN India&lt;br&gt;
						en_IE Ireland&lt;br&gt;
						zh_HK Hong Kong&lt;br&gt;
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<SeeLink>
							<URL>http://www.ietf.org/rfc/rfc3066.txt</URL>
							<Title>Tags for the Identification of Languages</Title>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						In most cases, all calls support a MessageID element in the request and a
						CorrelationID element in the response. If you pass a message ID in a request,
						we will return the same value in CorrelationID in the response. You can use
						this for tracking that a response is returned for every request and to match
						particular responses to particular requests. If you do not pass MessageID in
						the request, CorrelationID is not returned. Note that some calls are designed
						to retrieve large sets of meta-data that only change once a day or less often.
						To improve performance, these calls return cached responses when you request
						all available data (with no filters). In these cases, the correlation ID is
						not applicable. However, if you specify an input filter to reduce the amount
						data returned, you can use MessageID and CorrelationID for these meta-data
						calls. These are the meta-data calls that can return cached responses:
						GetCategories, GetAttributesCS, GetCategory2CS, GetAttributesXsl,
						GetProductFinder, GetProductFinderXsl, and GetProductSearchPage.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Version" type="xs:string"  minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The version of the request payload schema. If you are using the SOAP API, this
						field is required in the body of the request. Specify the version of the
						schema your application is using. If you are using the XML API, this field has
						no effect. Instead, specify the version in the X-EBAY-API-COMPATIBILITY-LEVEL
						HTTP header. (eBay only uses the value in this HTTP header when processing XML
						API requests. If you specify Version in the body of an XML API request and it
						is different from the value in the HTTP header, eBay returns an informational
						warning that the value in the HTTP header was used instead.) The version you
						specify for a call has two effects:&lt;br&gt;
						- It directly indicates the version of the code lists and other data that eBay
						should use to process your request.&lt;br&gt;
						- It indirectly indicates the API compatibility level of the data and
						functionality you are using.&lt;br&gt;
						See the eBay Web Services guide for information about schema versions, code
						lists, and compatibility levels.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorHandling" type="ns:ErrorHandlingCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Error tolerance level for the call. For calls that support Item Specifics,
						this is a preference that controls how eBay handles listing requests when
						invalid attribute data is passed in. See Attribute Error Handling in the
						eBay Web Services guide for details about this field in listing requests.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>CompleteSale</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvocationID" type="ns:UUIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A unique identifer for a particular call. If the same InvocationID is passed
						in after it has been passed in once on a call that succeeded for a particular
						application and user, then an error will be returned. The identifier can
						only contain digits from 0-9 and letters from A-F. The
						identifier must be 32 characters long.  For example,
						1FB02B2-9D27-3acb-ABA2-9D539C374228.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>32</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddMemberMessage</CallName>
							<CallName>AddOrder</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>AddToItemDescription</CallName>
							<CallName>PlaceOffer</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WarningLevel" type="ns:WarningLevelCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Controls whether or not to return warnings when the application passes
						unrecognized elements in a request (i.e., elements that are not defined in the
						schema). (This does not control warnings related to unrecognized values within
						elements.) Schema element names are case-sensitive, so this option can also
						help you remove any potential hidden bugs within your application due to
						incorrect case or spelling in tag names before you put your application into
						the Production environment. Note that this setting only validates elements; it
						does not validate XML attributes.&lt;br&gt;
						&lt;br&gt;
						We recommend that you only use this during development and debugging. Do not
						use this in requests in your production code.&lt;br&gt;
					</xs:documentation>
					<xs:appinfo>
					  <CallInfo>
							<AllCalls/>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<SeeLink>
							<URL>https://ebay.custhelp.com/cgi-bin/ebay.cfg/php/enduser/std_adp.php?p_faqid=499</URL>
							<Title>Warning Level</Title>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/AbstractResponseType.xsd #####

-->
	<xs:complexType name="AbstractResponseType" abstract="true">
		<xs:annotation>
			<xs:documentation>
				Base type definition of a response payload that can carry any
				type of payload content with following optional elements:&lt;br&gt;
				- timestamp of response message&lt;br&gt;
				- application-level acknowledgement&lt;br&gt;
				- application-level (business-level) errors and warnings
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Timestamp" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This value represents the date and time when eBay processed the
						request. The time zone of this value is GMT and the format is the
						ISO 8601 date and time format (YYYY-MM-DDTHH:MM:SS.SSSZ). See Time
						Values in the eBay Web Services guide for information about this
						time format and converting to and from the GMT time zone. Certain
						calls, such as GetCategories, can return very large responses that
						change once a day or less often. For better performance, such calls
						may return cached data. In these cases, this time value reflects the
						time the cached response was created. Thus, this value is not
						necessarily within a few seconds of the time you submitted the
						request.
						These are the meta-data calls that can return cached responses:
						GetCategories, GetAttributesCS, GetCategory2CS, GetAttributesXsl,
						GetProductFinder, GetProductFinderXsl, and GetProductSearchPage.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Ack" type="ns:AckCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A token representing the application-level acknowledgement code that indicates
						the response status (e.g., success). The AckCodeType list specifies
						the possible values for Ack.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CorrelationID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						In most cases, all calls support a MessageID element in the request
						and a CorrelationID element in the response. If you pass a message
						ID in a request, we will return the same value in CorrelationID in
						the response. You can use this for tracking that a response is
						returned for every request and to match particular responses to
						particular requests. If you do not pass MessageID in the request,
						CorrelationID is not returned. Note that some calls are designed to
						retrieve large sets of meta-data that only change once a day or less
						often. To improve performance, these calls return cached responses
						when you request all available data (with no filters). In these
						cases, the correlation ID is not applicable. However, if you specify
						an input filter to reduce the amount data returned, you can use
						MessageID and CorrelationID for these meta-data calls.
						These are the calls that can return cached responses:
						GetCategories, GetAttributesCS, GetCategory2CS, GetAttributesXsl,
						GetProductFinder, GetProductFinderXsl, and GetProductSearchPage.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Errors" type="ns:ErrorType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A list of application-level errors (if any) that occurred when eBay
						processed the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Message" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Supplemental information from eBay, if applicable. May elaborate on errors or
						provide useful hints for the seller. This data can accompany the call's normal
						data result set or a result set that contains only errors. The string can
						return HTML, including TABLE, IMG, and HREF elements. In this case, an HTML-
						based application should be able to include the HTML as-is in the HTML page
						that displays the results. A non-HTML application would need to parse the HTML
						and convert the table elements and image references into UI elements
						particular to the programming language used. Because this data is returned as
						a string, the HTML markup elements are escaped with character entity
						references (e.g.,&amp;lt;table&amp;gt;&amp;lt;tr&amp;gt;...). See the
						appendices in the eBay Web Services guide for general information about string
						data types.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddToItemDescription</CallName>
							<CallName>EndItem</CallName>
							<CallName>PlaceOffer</CallName>
							<CallName>RelistItem</CallName>
							<CallName>RespondToWantItNowPost</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Version" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The version of the response payload schema. Indicates the version of the
						schema that eBay used to process the request.
						See "Standard Data for All Calls" in the eBay Web Services Guide for information
						on using the response version when troubleshooting "CustomCode" values that appear
						in the response.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Build" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This refers to the specific software build that eBay used when processing the request
						and generating the response. This includes the version number plus additional
						information. eBay Developer Support may request the build information
						when helping you resolve technical issues.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NotificationEventName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Event name of the notification. Only returned by Platform Notifications.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="DuplicateInvocationDetails" type="ns:DuplicateInvocationDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Information that explains a failure due to a duplicate InvocationID being
						passed in.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddMemberMessage</CallName>
							<CallName>AddOrder</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>AddToItemDescription</CallName>
							<CallName>PlaceOffer</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RecipientUserID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Recipient user ID of the notification. Only returned by Platform Notifications.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="EIASToken" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique Identifier of Recipient user ID of the notification. Only returned by
						Platform Notifications (not for regular API call responses).
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="NotificationSignature" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A Base64-encoded MD5 hash that allows the recipient of a Platform
						Notification to verify this is a valid Platform Notification sent by
						eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="HardExpirationWarning" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Expiration date of the user's authentication token. Only returned
						within the 7-day period prior to a token's expiration. To ensure
						that user authentication tokens are secure and to help avoid a
						user's token being compromised, tokens have a limited life span. A
						token is only valid for a period of time (set by eBay). After this
						amount of time has passed, the token expires and must be replaced
						with a new token.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCallsExcept>FetchToken, GetReturnURL, GetRuName, SetReturnURL</AllCallsExcept>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/AckCodeList.xsd #####

-->
	<xs:simpleType name="AckCodeType">
		<xs:annotation>
			<xs:documentation>
AckCodeType - Type declaration to be used by other schema.
This code identifies the acknowledgement code types that 
eBay could use to communicate the status of processing a 
(request) message to an application. This code would be used 
as part of a response message that contains an  
application-level acknowledgement element.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Success">
				<xs:annotation>
					<xs:documentation>
					   (out) Request processing succeeded
				      </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Failure">
				<xs:annotation>
					<xs:documentation> 
					   (out) Request processing failed
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Warning">
				<xs:annotation>
					<xs:documentation>
					   (out) Request processing completed with warning information
					   being included in the response message
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PartialFailure">
				<xs:annotation>
					<xs:documentation>
						(out) Request processing completed with some failures.
						See the Errors data to determine which portions of the request failed.
					 </xs:documentation>
					 <xs:appinfo>
					 	<CallInfo>
					 		<CallName>CompleteSale</CallName>
					 		<CallName>GetPopularKeywords</CallName>
							<Returned>Conditionally</Returned>
					 	</CallInfo>
					 </xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/BuyerPaymentMethodCodeList.xsd #####

-->
	<xs:simpleType name="BuyerPaymentMethodCodeType">
		<xs:annotation>
			<xs:documentation>
				Identifies payment methods used by a buyer to pay a
				seller. On item listings, identifies one of the payment methods
				seller will accept for the item. Available payment methods can 
				differ by site and item. Payment methods are not applicable to eBay 
				Real Estate ad format listings.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(in/out) No payment method specified.
						For example, no payment methods would be specified for Ad format listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ReviseCheckoutStatus</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MOCC">
				<xs:annotation>
					<xs:documentation>
						(in/out) Money order/cashiers check.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>RelistItem</CallName>						  
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AmEx">
				<xs:annotation>
					<xs:documentation>
						(in/out) American Express.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentSeeDescription">
				<xs:annotation>
					<xs:documentation>
						(in/out) Payment instructions are contained in the item's description.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CCAccepted">
				<xs:annotation>
					<xs:documentation>
						(in/out) Credit card. 
						Not applicable to Real Estate or US/CA eBay Motors listings.  
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PersonalCheck">
				<xs:annotation>
					<xs:documentation>
						(in/out) Personal check.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="COD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cash on delivery. 
						This payment method is obsolete (ignored) for the US, US eBay Motors, UK, and Canada sites. 
						See "Field Differences for eBay Sites" in the eBay Web Services Guide for a list of sites 
						that accept COD as a payment method. Not applicable to Real Estate listings. 
						When revising an item (on sites that still support COD), you can add or change its value. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
							<CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VisaMC">
				<xs:annotation>
					<xs:documentation>
						(in/out) Visa/Mastercard.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaisaPayAccepted">
				<xs:annotation>
					<xs:documentation>
						(in/out) PaisaPay (for India site only).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other forms of payment. Some custom methods are accepted by seller
						as the payment method in the transaction.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPal">
				<xs:annotation>
					<xs:documentation>
						(in/out) PayPal is accepted as a payment method. If true for a listing, Item.PayPalEmailAddress 
						must also be set for the listing.
						If you don't pass PayPal in the listing request but the seller's eBay preferences are set to accept PayPal 
						on all listings, eBay will add PayPal as a payment method and return a warning.
						PayPal must be accepted when the seller requires immediate payment (Item.AutoPay) or 
						offers other PayPal-based features, such as a finance offer (Item.FinanceOfferID).
						PayPal must be accepted for charity listings.
						PayPal must be accepted for event ticket listings when the venue is in New York state or Illinois, 
						so that eBay can offer buyer protection (per state law). (For some applications, it may be 
						simplest to use errors returned from VerifyAddItem to flag the PayPal requirement for 
						New York and Illinois ticket listings.) 
						For additional information about PayPal, see the eBay Web Services Guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Discover">
				<xs:annotation>
					<xs:documentation>
						(in/out) Discover card.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CashOnPickup">
				<xs:annotation>
					<xs:documentation>
						(in/out) Payment on delivery.
						Not applicable to Real Estate or US/CA eBay Motors listings. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MoneyXferAccepted">
				<xs:annotation>
					<xs:documentation>
						(in/out) Direct transfer of money.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MoneyXferAcceptedInCheckout">
				<xs:annotation>
					<xs:documentation>
						(in/out) If the seller has bank account information on file, and
						MoneyXferAcceptedInCheckout = true, then the bank account information will
						be displayed in Checkout. Applicable only to certain global eBay sites. See
						the "International Differences Overview" in the eBay Web Services Guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>							
						  <CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OtherOnlinePayments">
				<xs:annotation>
					<xs:documentation>
						(in/out) All other online payments.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>VerifyAddItem</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Escrow">
				<xs:annotation>
					<xs:documentation>
						(in/out) China site payment method: Escrow managed payment.
						If a seller on the eBay China site has a feedback score less than 5 
						OR a positive feedback rate less than 90% OR the seller is unverified 
						(CN verified status), then escrow is required for the seller to list an 
						item. If escrow is required and an attempt is made to list an item 
						without offering escrow, then an error message is returned. For additional
						information, see the International Differences Overview in the eBay Web Services Guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PrePayDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) China site payment method: PrePayDelivery.  
						NOTE: This value is deprecated.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>VerifyAddItem</CallName>						  
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						  <TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						  <TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CODPrePayDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cash On Delivery After Paid. Applicable for eBay China site only (site ID 223).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PostalTransfer">
				<xs:annotation>
					<xs:documentation>
						(in/out) China site payment method: PostalTransfer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>VerifyAddItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LoanCheck">
				<xs:annotation>
					<xs:documentation>
						(in/out) Loan check option (applicable only to the US eBay Motors site,
						except in the Parts and Accessories category, and the eBay Canada site for motors).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>VerifyAddItem</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CashInPerson">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cash-in-person option. Applicable only to US and Canada eBay Motors vehicles,
						(not the Parts and Accessories category).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>VerifyAddItem</CallName>
						  <RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/CustomSecurityHeaderType.xsd #####

-->
	<xs:complexType name="CustomSecurityHeaderType">
		<xs:annotation>
			<xs:documentation>
				Security header used for SOAP API calls.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="eBayAuthToken" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Authentication token representing the user who is making the
						request. The user's token must be retrieved from eBay. To determine
						a user's authentication token, see the Authentication and
						Authorization information in the eBay Web Services guide. For calls
						that list or retrieve item or transaction data, the user usually
						needs to be the seller of the item in question or, in some cases,
						the buyer. Similarly, calls that retrieve user or account data may
						be restricted to the user whose data is being requested. The
						documentation for each call includes information about such
						restrictions.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>2000</MaxLength>
						<CallInfo>
							<AllCallsExcept>FetchToken, GetReturnURL, GetRuName, SetReturnURL</AllCallsExcept>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HardExpirationWarning" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Expiration date of the user's authentication token. Only returned
						within the 7-day period prior to a token's expiration. To ensure
						that user authentication tokens are secure and to help avoid a
						user's token being compromised, tokens have a limited life span. A
						token is only valid for a period of time (set by eBay). After this
						amount of time has passed, the token expires and must be replaced
						with a new token.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCallsExcept>FetchToken, GetReturnURL, GetRuName, SetReturnURL</AllCallsExcept>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Credentials" type="ns:UserIdPasswordType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Authentication information for the user on whose behalf the
						application is making the request, and authorization information for
						the application making the request. Only registered eBay users are
						allowed to make API calls. To verify that a user is registered, your
						application normally needs to pass a user-specific value called an
						"authentication token" in the request. This is equivalent to signing
						in on the eBay Web site. As API calls do not pass session
						information, you need to pass the user's authentication token every
						time you invoke a call on their behalf. All calls require an
						authentication token, except the calls you use to retrieve a token
						in the first place. For such calls, you use the eBay member's
						username and password instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>FetchToken</CallName>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NotificationSignature" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A Base64-encoded MD5 hash that allows the recepient of a Platform
						Notification to verify this is a valid Platform Notification sent by
						eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/DetailLevelCodeList.xsd #####

-->
	<xs:simpleType name="DetailLevelCodeType">
		<xs:annotation>
			<xs:documentation>
DetailLevelCodeType - Type declaration to be used by other schema.
Specifies standard subsets of data to return for each result
within the set of results in the response payload. If no
detail level is specified, a base set of data is returned.
The base set of data varies per call.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ReturnAll">
				<xs:annotation>
					<xs:documentation>
						(in) Returns all available data.
						With GetSellerList and other calls that retrieve large data sets,
						please avoid using ReturnAll when possible. For example, if you use
						GetSellerList, use a GranularityLevel or use the
						GetSellerEvents call instead. If you use ReturnAll with GetSellerList,
						use a small EntriesPerPage value and a short
						EndTimeFrom/EndTimeTo range for better performance.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemReturnDescription">
				<xs:annotation>
					<xs:documentation>
						  (in) Returns Description, plus the
						  ListingDesigner node and some additional information if applicable
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemReturnAttributes">
				<xs:annotation>
					<xs:documentation>
						  (in) Returns Item Specifics and Pre-filled Item Information,
						  if applicable
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemReturnCategories">
				<xs:annotation>
					<xs:documentation>
						  (in) For the GetSearchResults call, returns the primary category and, if applicable, the secondary category
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReturnSummary">
				<xs:annotation>
					<xs:documentation>
						(in) Returns the summary data.
						For GetMyMessages, this detail level returns the same data
						whether or not you include MessageIDs or AlertIDs in the
						request. Returns up to 10 FolderID and FolderName values.
						Currently, this detail level is the only way to retrieve
						FolderID and FolderName values. See "GetMyMessages" in the
						eBay Web Services Guide for a code sample that demonstrates
						this.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<CallNames>GetMyMessages</CallNames>
							<Title>"Retrieving FolderID and FolderName Values"</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/GetMyMessagesCall-GetMyMessages_Samples.html</URL>
						</SeeLink>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
		</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReturnHeaders">
				<xs:annotation>
					<xs:documentation>
						(in) Returns message headers.
						For GetMyMessages, if you include MessageIDs or AlertIDs in
						the request, this detail level returns header information,
						without body text, for the specified message ID or alert ID
						values. If you include a FolderID, header information is
						returned only for the messages and alerts in the specified
						folder.
						If you do not include MessageIDs or AlertIDs, this detail
						level returns header information for:
						- All alerts in priority order with the highest priority
						  alerts first
						- All messages in ascending order by date received with the
						  oldest messages first.
						Note that even when restricted by this detail level to
						return only header information, GetMyMessages may return a
						high volume of data.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReturnMessages">
				<xs:annotation>
					<xs:documentation>
						(in) Returns full message information.
						For GetMyMessages, if you include MessageIDs or AlertIDs in
						the request, this detail level returns message information
						for the specified message ID or alert ID values. If you
						include a FolderID, message information is returned only for
						the messages and alerts in the specified folder.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeActivityCodeList.xsd #####

-->
	<xs:simpleType name="DisputeActivityCodeType">
		<xs:annotation>
			<xs:documentation>
				Defines the action taken on a dispute with AddDisputeResponse. The value
				you can use at a given time depends on the current value of DisputeState
				(see the Developer Guide for more information). Some values are for
				Unpaid Item disputes and some are for Item Not Received disputes.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="SellerAddInformation">
				<xs:annotation>
					<xs:documentation>
						(in) The seller wants to add a response to the dispute. For Unpaid
						Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerCompletedTransaction">
				<xs:annotation>
					<xs:documentation>
						(in) The buyer has paid or the seller otherwise does not need to
						pursue the dispute any longer. For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CameToAgreementNeedFVFCredit">
				<xs:annotation>
					<xs:documentation>
						(in) The seller has made an agreement with the buyer and requires a
						credit for a Final Value Fee already paid. For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerEndCommunication">
				<xs:annotation>
					<xs:documentation>
						(in) The seller wants to end communication or stop waiting for the
						buyer. For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MutualAgreementOrNoBuyerResponse">
				<xs:annotation>
					<xs:documentation>
						(in) The seller wants to end communication or stop waiting for the
						buyer. Mutual agreement has been reached or the buyer has not
						responded within 7 days. For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerOffersRefund">
				<xs:annotation>
					<xs:documentation>
						(in) The seller offers a full refund if the buyer did not receive
						the item or a partial refund if the item is significantly not as
						described. For Item Not Received or Significantly Not As Described
						disputes. Can be used when DisputeState is:&lt;br&gt;
						NotReceivedNoSellerResponse&lt;br&gt;
						NotAsDescribedNoSellerResponse&lt;br&gt;
						NotReceivedMutualCommunication&lt;br&gt;
						NotAsDescribedMutualCommunication
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerShippedItem">
				<xs:annotation>
					<xs:documentation>
						(in) The seller has shipped the item or a replacement and provides
						shipping information. For Item Not Received and Significantly Not As
						Described disputes. Can be used when DisputeState is:&lt;br&gt;
						NotReceivedNoSellerResponse&lt;br&gt; NotReceivedMutualCommunication
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerComment">
				<xs:annotation>
					<xs:documentation>
						(in) The seller communicates with the buyer, offering a response or
						comment. For Item Not Received and Significantly Not As Described
						disputes. Can be used when DisputeState is:&lt;br&gt;
						NotReceivedNoSellerResponse&lt;br&gt;
						NotAsDescribedNoSellerResponse&lt;br&gt;
						NotReceivedMutualCommunication&lt;br&gt;
						NotAsDescribedMutualCommunication
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerPaymentNotReceived">
				<xs:annotation>
					<xs:documentation>
						(in) Seller hasn't received payment or the payment hasn't cleared
						yet. For Item Not Received disputes. Can be used when DisputeState
						is:&lt;br&gt; NotReceivedNoSellerResponse&lt;br&gt;
						NotReceivedMutualCommunication&lt;br&gt;
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeCreditEligibilityCodeList.xsd #####

-->
	<xs:simpleType name="DisputeCreditEligibilityCodeType">
		<xs:annotation>
			<xs:documentation>
			Indicates whether the dispute is currently eligible for Final Value Fee credit. The value
			does not indicate whether the credit will actually be made. Applies to Unpaid Item
			disputes.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="InEligible">
				<xs:annotation>
					<xs:documentation>
    					(out) The seller is not currently eligible for a credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Eligible">
				<xs:annotation>
					<xs:documentation>
    					(out) The seller is eligible for a credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeExplanationCodeList.xsd #####

-->
	<xs:simpleType name="DisputeExplanationCodeType">
		<xs:annotation>
			<xs:documentation>
			 Contains the dispute explanation, entered when the dispute was created.
			 Provides additional information to supplement the dispute reason. The values allowed
			 depend on the value of DisputeReason.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="BuyerHasNotResponded">
				<xs:annotation>
					<xs:documentation>
					 (in/out) The buyer has not responded within the 7-day waiting period.
					 Allowed when DisputeReason is BuyerHasNotPaid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerRefusedToPay">
				<xs:annotation>
					<xs:documentation>
					(in/out) The buyer has refused to pay. Allowed when DisputeReason is BuyerHasNotPaid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerNotClearedToPay">
				<xs:annotation>
					<xs:documentation>
					(in/out) The buyer is not cleared to pay. Allowed when DisputeReason is BuyerHasNotPaid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerReturnedItemForRefund">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer returned the item for a refund. Allowed when DisputeReason is TransactionMutuallyCanceled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UnableToResolveTerms">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer and seller were unable to resolve a disagreement over terms. Allowed when DisputeReason
    				is TransactionMutuallyCanceled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerNoLongerWantsItem">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer no longer wants the item. Allowed when DisputeReason is
    				TransactionMutuallyCanceled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerPurchasingMistake">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer made a mistake. Allowed when DisputeReason is
    				TransactionMutuallyCanceled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShipCountryNotSupported">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer requests shipment to a country that the seller
    				does not ship to. Allowed when DisputeReason is BuyerHasNotPaid.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddDispute</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingAddressNotConfirmed">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer requests shipment to an unconfirmed address.
    				Allowed when DisputeReason is BuyerHasNotPaid or TransactionMutuallyCanceled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentMethodNotSupported">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer requests a payment method that the seller does not accept.
    				Allowed when DisputeReason is BuyerHasNotPaid or TransactionMutuallyCanceled.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddDispute</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerNoLongerRegistered">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer is no longer a registered user.
    				Allowed when DisputeReason is BuyerHasNotPaid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OtherExplanation">
				<xs:annotation>
					<xs:documentation>
    				(in/out) Some other reason not specified in this code list.
    				Allowed when DisputeReason is BuyerHasNotPaid or TransactionMutuallyCanceled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Unspecified">
				<xs:annotation>
					<xs:documentation>
					(in/out) Used when DisputeReason is ItemNotReceived or SignificantlyNotAsDescribed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                	(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeFilterCountType.xsd #####

-->
	<xs:complexType name="DisputeFilterCountType">
		<xs:annotation>
			<xs:documentation>
				The number of disputes that match a given filter.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DisputeFilterType" type="ns:DisputeFilterTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A filter used to reduce the number of disputes returned. The filter uses criteria
						such as whether the dispute is awaiting a response, is closed, or is eligible for
						credit. Both Unpaid Item and Item Not Received disputes can be returned for the
						same filter value.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The number of disputes that match the filter.
						In the GetUserDisputes response, not returned for the filter type
						that was used in the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/DisputeFilterTypeCodeList.xsd #####

-->
	<xs:simpleType name="DisputeFilterTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies which disputes are returned. Filtering is done for disputes
			that are awaiting a certain party's response or are closed. The returned list
			can contain both Unpaid Item and Item Not Received disputes.
			All disputes returned involve the requester as buyer or seller.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AllInvolvedDisputes">
				<xs:annotation>
					<xs:documentation>
					(in) All disputes that involve me as buyer or seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputesAwaitingMyResponse">
				<xs:annotation>
					<xs:documentation>
					(in) All disputes that involve me as buyer or seller and
					are awaiting my response. Default value.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputesAwaitingOtherPartyResponse">
				<xs:annotation>
					<xs:documentation>
					(in) All disputes that involve me as buyer or seller and
					are awaiting the other party's response.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllInvolvedClosedDisputes">
				<xs:annotation>
					<xs:documentation>
					(in) All disputes that involve me as buyer or seller and
					are closed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EligibleForCredit">
				<xs:annotation>
					<xs:documentation>
					(in) All disputes that involve me as buyer or seller and
					are eligible for a Final Value Fee credit, whether or not
					the credit has been granted.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UnpaidItemDisputes">
				<xs:annotation>
					<xs:documentation>
					(in) All Unpaid item disputes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemNotReceivedDisputes">
				<xs:annotation>
					<xs:documentation>
					(in) All Item Not Received disputes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                	(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeIDType.xsd #####

-->
	<xs:simpleType name="DisputeIDType">
		<xs:annotation>
			<xs:documentation>
				An identifier of a dispute.			
 			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeMessageSourceCodeList.xsd #####

-->
	<xs:simpleType name="DisputeMessageSourceCodeType">
		<xs:annotation>
			<xs:documentation>
			  Defines who added a message to a dispute. Used for both Unpaid Item
			  and Item Not Received disputes.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Buyer">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer of the item under dispute.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Seller">
				<xs:annotation>
					<xs:documentation>
					(out) The seller of the item under dispute.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBay">
				<xs:annotation>
					<xs:documentation>
					(out) eBay, either an administrator or the site itself.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                	(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeMessageType.xsd #####

-->
	<xs:complexType name="DisputeMessageType">
		<xs:annotation>
			<xs:documentation>
				Contains a message posted to a dispute. The message can be posted
				by the buyer, the seller, or an eBay representative.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MessageID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An ID that uniquely identifies the message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageSource" type="ns:DisputeMessageSourceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The party who posted the message: the buyer, the seller,
						or an eBay representative.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageCreationTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time the message was created, in GMT.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageText" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The text of the message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/DisputeReasonCodeList.xsd #####

-->
	<xs:simpleType name="DisputeReasonCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies the top-level reason for the dispute and determines the values you
			can use for DisputeExplanation. Some values are for Item Not Received disputes
			and others are for Unpaid Item Process disputes.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="BuyerHasNotPaid">
				<xs:annotation>
					<xs:documentation>
    					(in/out) The buyer has not paid for the item. For Unpaid Item Process disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TransactionMutuallyCanceled">
				<xs:annotation>
					<xs:documentation>
    				(in/out) The buyer and seller have agreed not to complete the transaction.
    				For Unpaid Item Process disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemNotReceived">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer did not receive the item. An output value for Item Not Received disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SignificantlyNotAsDescribed">
				<xs:annotation>
					<xs:documentation>
					(out) The item was significantly not as described in the listing. 
					An output value for Item Not Received disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeRecordTypeCodeList.xsd #####

-->
	<xs:simpleType name="DisputeRecordTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			Describes the type of dispute, either Unpaid Item or Item Not Received.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="UnpaidItem">
				<xs:annotation>
					<xs:documentation>
    					(out) An Unpaid Item dispute.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemNotReceived">
				<xs:annotation>
					<xs:documentation>
    				(out) An Item Not Received dispute.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                	(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeResolutionReasonCodeList.xsd #####

-->
	<xs:simpleType name="DisputeResolutionReasonCodeType">
		<xs:annotation>
			<xs:documentation>
			Defines the reason a dispute was resolved. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unresolved">
				<xs:annotation>
					<xs:documentation>	
					(out) The dispute was not resolved.			
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProofOfPayment">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer provided proof of payment in feedback.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ComputerTechnicalProblem">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer or seller had a technical problem with a computer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NoContact">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer and seller have not made contact.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FamilyEmergency">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer or seller had a family emergency.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProofGivenInFeedback">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer provided proof of payment in feedback.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FirstInfraction">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute was the buyer's first infraction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CameToAgreement">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer and seller came to agreement.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemReturned">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer returned the item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerPaidAuctionFees">
				<xs:annotation>
					<xs:documentation>
 					(out) The buyer reimbursed the seller's auction fees.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReceivedPayment">
				<xs:annotation>
					<xs:documentation>
					(out) The seller received payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OtherResolution">
				<xs:annotation>
					<xs:documentation>
					(out) Some other resolution occurred.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeResolutionRecordTypeCodeList.xsd #####

-->
	<xs:simpleType name="DisputeResolutionRecordTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies the action taken by eBay as a result of the dispute resolution.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="StrikeBuyer">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer received an Unpaid Item Strike.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SuspendBuyer">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer is suspended and unable to use
					the eBay site.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FVFCredit">
				<xs:annotation>
					<xs:documentation>
					(out) The seller received a Final Value Fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InsertionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) The seller's listing fee was credited.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AppealBuyerStrike">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer's unpaid item strike was appealed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UnsuspendBuyer">
				<xs:annotation>
					<xs:documentation>
					(out)The buyer's suspension was reversed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReverseFVFCredit">
				<xs:annotation>
					<xs:documentation>
					(out) The seller's Final Value Fee credit was reversed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReverseInsertionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) The seller's listing fee was reversed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GenerateCSTicketForSuspend">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer is given a ticket.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FVFCreditNotGranted">
				<xs:annotation>
					<xs:documentation>
					(out) The seller did not receive a Final Value Fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                	(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeResolutionType.xsd #####

-->
	<xs:complexType name="DisputeResolutionType">
		<xs:annotation>
			<xs:documentation>
				Contains all information about a dispute resolution. A dispute
				can have a resolution even if the seller does not receive payment.
				The resolution can have various results, including a Final Value Fee credit to
				the seller or a strike to the buyer.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DisputeResolutionRecordType" type="ns:DisputeResolutionRecordTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The action resulting from the resolution, affecting either
						the buyer or the seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeResolutionReason" type="ns:DisputeResolutionReasonCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The reason for the resolution. The DisputeResolutionReason
						results in the action described by the DisputeResolutionRecordType.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResolutionTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time the dispute was resolved, in GMT.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/DisputeSortTypeCodeList.xsd #####

-->
	<xs:simpleType name="DisputeSortTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies how a list of returned disputes should be sorted.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the time the dispute was created, in descending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputeCreatedTimeAscending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the time the dispute was created, in ascending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputeCreatedTimeDescending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the time the dispute was created, in descending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputeStatusAscending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the dispute status, in ascending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputeStatusDescending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the dispute status, in descending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputeCreditEligibilityAscending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by whether the dispute is eligible for
					Final Value Fee credit, in ascending
					order. Ineligible disputes are listed before eligible disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DisputeCreditEligibilityDescending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by whether the dispute is eleigible for
					Final Value Fee credit, in descending
					order. Eligible disputes are listed before i(ineligible disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeStateCodeList.xsd #####

-->
	<xs:simpleType name="DisputeStateCodeType">
		<xs:annotation>
			<xs:documentation>
				Defines the current state of the dispute, which determines the values
				that are valid for DisputeActivity. DisputeState is an internal value
				returned in the response. A value can apply to an Unpaid Item or Item
				Not Received dispute. A dispute filed when an item is significantly not
				as described in the product listing is a variation of an Item Not
				Received dispute.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Locked">
				<xs:annotation>
					<xs:documentation>
						(out) The dispute is locked and cannot be updated. For any type of
						dispute. No values of DisputeActivity are vald.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Closed">
				<xs:annotation>
					<xs:documentation>
						(out) The dispute is closed. In some cases, it can be reversed with
						SellerReverseDispute. For any type of dispute. No values of
						DisputeActivity are valid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerFirstResponsePayOption">
				<xs:annotation>
					<xs:documentation>
						(out) eBay sent the buyer an Unpaid Item Reminder with a Pay Now
						option. Waiting for the buyer's first response. It is within the 7-
						day grace period. For Unpaid Item disputes. DisputeActivity can be
						SellerAddInformation or SellerCompletedTransaction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerFirstResponseNoPayOption">
				<xs:annotation>
					<xs:documentation>
						(out) eBay sent the buyer an Unpaid Item Reminder with no Pay Now
						option. Waiting for the buyer's first response. It is within the 7-
						day grace period. For Unpaid Item disputes. DisputeActivity can be
						SellerAddInformation or SellerCompletedTransaction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerFirstResponsePayOptionLateResponse">
				<xs:annotation>
					<xs:documentation>
						(out) eBay sent the buyer an Unpaid Item Reminder with a Pay Now
						option. Waiting for the buyer's first response. The 7-day grace
						period has expired. For Unpaid Item disputes. DisputeActivity can be
						SellerAddInformation, SellerCompletedTransaction, or
						SellerEndCommunication.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerFirstResponseNoPayOptionLateResponse">
				<xs:annotation>
					<xs:documentation>
						(out) eBay sent the buyer an Unpaid Item Reminder with no Pay Now
						option. Waiting for the buyer's first response. The 7-day grace
						period has expired. For Unpaid Item disputes. DisputeActivity can be
						SellerAddInformation, SellerCompletedTransaction, or
						SellerEndCommunication.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MutualCommunicationPayOption">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer and seller have communicated, and the buyer was
						offered a Pay Now option. For Unpaid Item disputes. DisputeActivity
						can be SellerAddInformation, SellerCompletedTransaction,
						SellerEndCommunication, or CameToAgreementNeedFVFCredit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MutualCommunicationNoPayOption">
				<xs:annotation>
					<xs:documentation>
				    (out) The buyer and seller have communicated. The buyer does not
						have a Pay Now option. For Unpaid Item disputes. DisputeActivity can
						be SellerAddInformation, SellerCompletedTransaction,
						SellerEndCommunication, or CameToAgreementNeedFVFCredit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PendingResolve">
				<xs:annotation>
					<xs:documentation>
						(out) The dispute is pending resolution. For Unpaid Item disputes.
						No values of DisputeActivity are valid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MutualWithdrawalAgreement">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer and seller have agreed within the grace period not
						to complete the transaction. For Unpaid Item disputes.
						DisputeActivity can be SellerAddInformation.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MutualWithdrawalAgreementLate">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer and seller have agreed not to complete the
						transaction, after the grace period. For Unpaid Item disputes.
						DisputeActivity can be SellerAddInformation,
						SellerCompletedTransaction, or SellerEndCommunication.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotReceivedNoSellerResponse">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer filed an Item Not Received dispute, and the seller
						has not responded. For Item Not Received disputes. DisputeActivity
						can be SellerOffersRefund, SellerShippedItem, or SellerComment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotAsDescribedNoSellerResponse">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer filed an Item Not Received dispute for an item
						significantly not as described, and the seller has not responded.
						DisputeActivity can be SellerOffersRefund or SellerComment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotReceivedMutualCommunication">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer filed an Item Not Received dispute and is
						communicating with the seller. DisputeActivity can be
						SellerOffersRefund, SellerShippedItem, or SellerComment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotAsDescribedMutualCommunication">
				<xs:annotation>
					<xs:documentation>
						(out) The buyer filed an Item Not Received dispute for an item
						significantly not as described and is communicating with the seller.
						DisputeActivity can be SellerOffersRefund.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MutualAgreementOrBuyerReturningItem">
				<xs:annotation>
					<xs:documentation>
						(out) The seller says mutual agreement has been reached and is
						waiting for the buyer to confirm, or the buyer is returning the item
						to the seller. DisputeActivity can be SellerAddInformation.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DisputeStatusCodeList.xsd #####

-->
	<xs:simpleType name="DisputeStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			Describes the status of the dispute, which supplements the DisputeState.
			Some values apply to Unpaid Item disputes and some to Item Not Received disputes.
			Disputes can be sorted by DisputeStatus. Ascending order is:&lt;br&gt;
			 1 - WaitingForSellerResponse&lt;br&gt;
			 2 - WaitingForBuyerResponse&lt;br&gt;
			 3 - ClosedFVFCreditStrike&lt;br&gt;
			 4 - ClosedNoFVFCreditStrike&lt;br&gt;
			 5 - ClosedFVFCreditNoStrike&lt;br&gt;
			 6 - ClosedNoFVFCreditNoStrike&lt;br&gt;
			 7 - Closed&lt;br&gt;
			 8 - StrikeAppealedAfterClosing&lt;br&gt;
			 9  - FVFCreditReversedAfterClosing&lt;br&gt;
			 10 - StrikeAppealedAndFVFCreditReversed&lt;br&gt;
			Descending order is the reverse.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Closed">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is closed. For Item Not Received disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WaitingForSellerResponse">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is waiting for the seller's response. For both
					Unpaid Item and Item Not Received disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WaitingForBuyerResponse">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is waiting for the buyer's response. For both
					Unpaid Item and Item Not Received disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClosedFVFCreditStrike">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is closed, the seller received
					a Final Value Fee credit, and the buyer received a strike.
					For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClosedNoFVFCreditStrike">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is closed, the seller did not receive
					a Final Value Fee credit, and the buyer received a strike.
					For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClosedFVFCreditNoStrike">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is closed, the seller received a
					Final Value Fee credit, and the buyer did not receive a strike.
					For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClosedNoFVFCreditNoStrike">
				<xs:annotation>
					<xs:documentation>
					(out) The dispute is closed, the seller did not receive
					a Final Value Fee credit, and the buyer did not receive a strike.
					For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StrikeAppealedAfterClosing">
				<xs:annotation>
					<xs:documentation>
					(out) The buyer's strike was appealed after the dispute was closed.
					For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FVFCreditReversedAfterClosing">
				<xs:annotation>
					<xs:documentation>
					(out) The seller's Final Value Fee credit was reversed after the
					dispute was closed. For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StrikeAppealedAndFVFCreditReversed">
				<xs:annotation>
					<xs:documentation>
					(out) Both the seller's Final Value Fee credit and the buyer's strike
					were reversed after the dispute was closed. For Unpaid Item disputes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/DuplicateInvocationDetailsType.xsd #####

-->
	<xs:complexType name="DuplicateInvocationDetailsType">
		<xs:annotation>
			<xs:documentation>
				Contains properties that provide information on duplicate uses of InvocationIDs.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DuplicateInvocationID" type="ns:UUIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The duplicate InvocationID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddMemberMessage</CallName>
							<CallName>AddOrder</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>AddToItemDescription</CallName>
							<CallName>PlaceOffer</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<CallName>ReviseItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:InvocationStatusType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The status of the previous call that used the InvocationID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddMemberMessage</CallName>
							<CallName>AddOrder</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>AddToItemDescription</CallName>
							<CallName>PlaceOffer</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvocationTrackingID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						The id that identifies the business item the previous API invocation 
						created. For example, the ItemID of the item created by an AddItem call.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddMemberMessage</CallName>
							<CallName>AddOrder</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>AddToItemDescription</CallName>
							<CallName>PlaceOffer</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/ErrorClassificationCodeList.xsd #####

-->
	<xs:simpleType name="ErrorClassificationCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="RequestError">
				<xs:annotation>
					<xs:documentation>
					An error has occurred either as a result of a problem in the sending application or because
					the application's end-user has attempted to submit invalid data (or missing data).
					In these cases, do not retry the request. The problem must be corrected before the request
					can be made again. If the problem is due to something in the application (such as a missing
					required field), the application must be changed. If the problem is a result of end-user data,
					the application must alert the end-user to the problem and provide the means for the end-user
					to correct the data. Once the problem in the application or data is resolved, resend the request to eBay
					with the corrected data.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SystemError">
				<xs:annotation>
					<xs:documentation>
					Indicates that an error has occurred on the eBay system side, such as a database or server down.
					An application can retry the request as-is a reasonable number of times (eBay recommends twice).
					If the error persists, contact Developer Technical Support. Once the problem has been resolved,
					the request may be resent in its original form.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/ErrorHandlingCodeList.xsd #####

-->
	<xs:simpleType name="ErrorHandlingCodeType">
		<xs:annotation>
			<xs:documentation>
Preferences that specify how eBay should handle certain requests that contain 
invalid data or that could partially fail. 
These preferences give you some control over whether eBay returns warnings or errors in response to 
invalid data and how eBay handles listing requests when such data is passed in. 
For example, these preferences are applicable to AddItem and related calls when Item Specifics 
are specified, and to CompleteSale.
See the developer guide for details about these preferences, their effects, and defaults for
applicable calls, 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Legacy">
				<xs:annotation>
					<xs:documentation>
         (in) Apply validation rules that were in effect prior to the time the 
         call started supporting ErrorHandling. 
         As of March 2005, only applicable to listing requests that include Item Specifics.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestEffort">
				<xs:annotation>
					<xs:documentation>
         (in) Drop the invalid data, continue processing the request with the valid data.
         If dropping the invalid data leaves the request in a state where required data is missing, 
         reject the request. See the developer guide for applicable calls and features.
         For the AddItem family of calls, this value is used as the default error handling preference 
         (if no preference is specified).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>CompleteSale</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllOrNothing">
				<xs:annotation>
					<xs:documentation>
         (in) As of March 2005, only applicable to listing requests that include Item Specifics. 
         If any attribute data is invalid, drop the entire attribute set and proceed with listing the item. 
         If the category has required attributes and the attribute set is dropped, reject the listing. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FailOnError">
				<xs:annotation>
					<xs:documentation>
         (in) If any data is invalid, reject the request.
         See the developer guide for information about applicable calls and features.
         For CompleteSale, this value is used as the default error handling preference 
         (if BestEffort is not specified).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>CompleteSale</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/ErrorParameterType.xsd #####

-->
	<xs:complexType name="ErrorParameterType">
		<xs:annotation>
			<xs:documentation>
				A variable that contains specific information about the context of this error.
				For example, if you pass in an attribute set ID that does not match
				the specified category, the attribute set ID might be returned as an error parameter.
				Use error parameters to flag fields that users need to correct.
				Also use error parameters to distinguish between errors when multiple
				errors are returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Value" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The value of the variable (e.g., the attribute set ID)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="ParamID" type="xs:string">
			<xs:annotation>
				<xs:documentation>
				The index of the parameter in the list of parameter types returned
				within the error type.
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  
##### from file ../Shared/public/ErrorType.xsd #####

-->
	<xs:complexType name="ErrorType">
		<xs:annotation>
			<xs:documentation>
				These are request errors (as opposed to system errors) that occur due to problems
				with business-level data (e.g., an invalid combination of arguments) that
				the application passed in.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ShortMessage" type="xs:string"  minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A brief description of the condition that raised the error.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LongMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A more detailed description of the condition that raised the error.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorCode" type="xs:token" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A unique code that identifies the particular error condition that occurred.
						Your application can use error codes as identifiers
						in your customized error-handling algorithms.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserDisplayHint" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the error message text is intended to be displayed to an end user
						or intended only to be parsed by the application. If true or not present (the default),
						the message text is intended for the end user. If false, the message text is intended for
						the application, and the application should translate the error into a more appropriate message.
						Only applicable to Item Specifics errors and warnings returned from listing requests.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SeverityCode" type="ns:SeverityCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the error is a severe error (causing the request to fail)
						or an informational error (a warning) that should be communicated to the user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorParameters" type="ns:ErrorParameterType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						This optional element carries a list of context-specific
						error variables that indicate details about the error condition.
						These are useful when multiple instances of ErrorType are returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorClassification" type="ns:ErrorClassificationCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						API errors are divided between two classes: system errors and request errors.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<AllCalls/>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/FaultDetailsType.xsd #####

-->
	<xs:complexType name="FaultDetailsType">
		<xs:annotation>
			<xs:documentation>
            SOAP faults are used to indicate that an infrastructure error has occurred, 
            such as a problem on eBay's side with database or server going down, or a 
            problem with the client or server-side SOAP framework.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ErrorCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                  Error code can be used by a receiving application to debug a SOAP response 
                  message that contains one or more SOAP fault details. 
                  Each error code is uniquely defined for each fault scenario.
                  See the eBay documentation for more information.
                  Your application can use error codes as identifiers 
                  in your customized error-handling algorithms.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="Severity" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                   Indicates whether the error is a severe error (causing the request to fail)
                   or an informational error (a warning).
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="DetailedMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                   Description of the condition that caused the SOAP fault.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/InvocationStatusCodeList.xsd #####

-->
	<xs:simpleType name="InvocationStatusType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="InProgress">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Success">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Failure">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode"/>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/MeasureType.xsd #####

-->
	<xs:complexType name="MeasureType">
		<xs:annotation>
			<xs:documentation>
				Basic type for specifying measures and the system of measurement.
				A decimal value (e.g., 10.25) is meaningful
				as a measure when accompanied by a definition of the unit of measure (e.g., Pounds),
				in which case the value specifies the quantity of that unit.
				A MeasureType expresses both the value (a decimal) and, optionally, the unit and
				the system of measurement.
				Details such as shipping weights are specified as measure types.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:decimal">
				<xs:attribute name="unit" type="xs:token" use="optional">
					<xs:annotation>
						<xs:documentation>
							The unit of measure (e.g., Pounds).
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetItemShipping</CallName>
								<CallName>GetSellerTransactions</CallName>
								<Returned>Conditionally</Returned>
							</CallInfo>
							<CallInfo>
								<CallName>GetItem</CallName>
								<Returned>Conditionally</Returned>
								<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="system" type="ns:MeasurementSystemCodeType" use="optional">
					<xs:annotation>
						<xs:documentation>
							The system of measurement (e.g., Metric).
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetItem</CallName>
								<Returned>Conditionally</Returned>
								<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
<!--  
##### from file ../Shared/public/MeasurementSystemCodeList.xsd #####

-->
	<xs:simpleType name="MeasurementSystemCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="English">
				<xs:annotation>
					<xs:documentation>
					(in/out) English system of measurement.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Metric">
				<xs:annotation>
					<xs:documentation>
					(in/out) Metric system of measurement.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/PaginationType.xsd #####

-->
	<xs:complexType name="PaginationType">
		<xs:annotation>
			<xs:documentation>
				(in) Contains data for controlling pagination in API requests.
				Pagination of returned data is required for some calls and not
				needed in or not supported for some calls. See the documentation
				for individual calls to determine whether pagination is supported,
				required, or desirable.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EntriesPerPage" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in) Specifies the maximum number of entries to return in a single call.
						If the number of entries that can be returned is less
						than the value in EntriesPerPage, then the lower number
						is returned.
						For most calls, the max is 200 and the default is 25.
						For GetUserDisputes, the value is hard-coded at 200, and any input is ignored.
						See the documentation for other individual calls to determine the correct
						max and default values. For GetOrders, not applicable to eBay.com (for GetOrders, applicable to Half.com).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetFeedback</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetSellerTransactions</CallName>
							<CallName>GetWantItNowSearchResults</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetMemberMessages</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<Min>1</Min>
							<Max>50000</Max>
							<Default>50</Default>
							<CallName>GetProductSearchResults</CallName>
							<CallName>GetProductFamilyMembers</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<Min>1</Min>
							<Max>400</Max>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<Min>1</Min>
							<Max>200</Max>
							<Default>200</Default>
							<CallName>GetSellerPayments</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<Min>200</Min>
							<Max>200</Max>
							<Default>200</Default>
							<CallName>GetUserDisputes</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<Default>100</Default>
							<CallName>GetPopularKeywords</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PageNumber" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in) Specifies the number of the page of data to return in the current call.
						Default is 1 for most calls. For some calls, the default is 0.
						Specify a positive value equal to or lower than the number of pages available (which you determine by examining
						the results of your initial request).
						See the documentation for other individual calls to determine the correct
						default value. For GetOrders, not applicable to eBay.com (for GetOrders, applicable to Half.com).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetFeedback</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSellerTransactions</CallName>
							<CallName>GetWantItNowSearchResults</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<RequiredInput>No</RequiredInput>
							<Min>0</Min>
							<Max>2147483647</Max>
							<Default>0</Default>
						</CallInfo>
						<CallInfo>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetUserDisputes</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<CallName>GetProductFamilyMembers</CallName>
							<RequiredInput>No</RequiredInput>
							<Min>0</Min>
							<Max>2147483647</Max>
							<Default>0</Default>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<RequiredInput>No</RequiredInput>
							<Min>1</Min>
							<Max>2147483647</Max>
							<Default>1</Default>
						</CallInfo>
						<CallInfo>
							<CallName>GetPopularKeywords</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>1</Default>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/QuantityType.xsd #####

-->
	<xs:complexType name="QuantityType">
      <xs:annotation>
			<xs:documentation>
        Basic type for specifying quantities.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:decimal">
				<xs:attribute name="unit" type="xs:token" use="optional"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
<!--  
##### from file ../Shared/public/SeverityCodeList.xsd #####

-->
	<xs:simpleType name="SeverityCodeType">
		<xs:annotation>
			<xs:documentation>
SeverityCodeType - Type declaration to be used by other schema.
This code identifies the severity of an API error. A code indicates
whether there is an API-level error or warning that needs to be
communicated to the client.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Warning">
				<xs:annotation>
					<xs:documentation>
					   (out) Warning or informational error
				      </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Error">
				<xs:annotation>
					<xs:documentation> 
					   (out) Application-level error										
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/UUIDType.xsd #####

-->
	<xs:simpleType name="UUIDType">
		<xs:annotation>
			<xs:documentation>
		  	Specifies a universally unique identifier. The identifier can 
        only contain digits from 0-9 and letters from A-F. The 
        identifier must be 32 characters long.  For example, 
        9CEBD9A6825644EC8D06C436D6CF494B.        
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/UserIdPasswordType.xsd #####

-->
	<xs:complexType name="UserIdPasswordType">
		<xs:sequence>
			<xs:element name="AppId" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The application ID that is unique to each application you (or your company)
						has registered with the eBay Developers Program. If you are executing a call
						in the Sandbox, this is the "AppId" value that eBay issued to you when you
						received your Sandbox keys. If you are executing a call in Production, this is
						the "AppId" value that eBay issued to you when you received your Production
						keys.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>FetchToken</CallName>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DevId" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The unique developer ID that the eBay Developers Program issued to you (or
						your company). If you are executing a call in the Sandbox, this is the "DevId"
						value that eBay issued to you when you received your Sandbox keys. Typically,
						you receive your Sandbox keys when you register as a new developer. If you are
						executing a call in Production, this is the "DevId" value that eBay issued to
						you when you received your Production keys. Typically, you receive your
						Production keys when you certify an application.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>FetchToken</CallName>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AuthCert" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Authentication certificate that authenticates the application when making API
						calls. If you are executing a call in the Sandbox, this is the "CertId" value
						that eBay issued to you when you received your Sandbox keys. If you are
						executing a call in Production, this is the "CertId" value that eBay issued to
						you when you received your Production keys. This is unrelated to auth tokens.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>FetchToken</CallName>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Username" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						eBay user ID (i.e., eBay.com Web site login name) for the user the application
						is retrieving a token for. This is typically the application's end-user (not
						the developer).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>64</MaxLength>
						<CallInfo>
							<CallName>FetchToken</CallName>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Password" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Password for the user specified in Username.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>64</MaxLength>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
							<!-- N/A: FetchToken -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  
##### from file ../Shared/public/WarningLevelCodeList.xsd #####

-->
	<xs:simpleType name="WarningLevelCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Low">
				<xs:annotation>
					<xs:documentation>
					Do not return warnings when the application passes
					unrecognized elements in a request.
					This is the default value if WarningLevel is not specified.
 					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="High">
				<xs:annotation>
					<xs:documentation>
					Return warnings when the application passes
					unrecognized elements in a request.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  
##### from file ../Shared/public/XMLRequesterCredentialsType.xsd #####

-->
	<xs:complexType name="XMLRequesterCredentialsType">
		<xs:sequence>
			<xs:element name="Username" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						eBay user ID (i.e., eBay.com Web site login name) for the user the application
						is retrieving a token for. This is typically the application's end-user (not
						the developer).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>64</MaxLength>
						<CallInfo>
							<CallName>FetchToken</CallName>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Password" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Password for the user specified in Username.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>64</MaxLength>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<CallName>GetRuName</CallName>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
							<!-- N/A: FetchToken -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="eBayAuthToken" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Authentication token representing the user who is making the request. The
						user's token must be retrieved from eBay. To determine a user's authentication
						token, see the Authentication and Authorization information in the eBay Web
						Services guide. For calls that list or retrieve item or transaction data, the
						user usually needs to be the seller of the item in question or, in some cases,
						the buyer. Similarly, calls that retrieve user or account data may be
						restricted to the user whose data is being requested. The documentation for
						each call includes information about such restrictions.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>2000</MaxLength>
						<CallInfo>
							<AllCallsExcept>FetchToken, GetReturnURL, GetRuName, SetReturnURL</AllCallsExcept>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>


	<!--  

##### from file eBLBaseComponents/public/AccessRuleCurrentStatusCodeList.xsd #####

-->
	<xs:simpleType name="AccessRuleCurrentStatusCodeType">
      <xs:annotation>
        <xs:documentation>
Describes the current status of your application with regard to 
rules governing the number of times your application can
execute API calls.
        </xs:documentation>
      </xs:annotation>	  
		<xs:restriction base="xs:token">
			<xs:enumeration value="NotSet">
				<xs:annotation>
  					<xs:documentation>
	    			  (out) The rule is not set and usage limits do not apply.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HourlyLimitExceeded">
				<xs:annotation>
  					<xs:documentation>
	    			 (out) Your application has exceeded its hourly hard limit.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="DailyLimitExceeded">
				<xs:annotation>
					<xs:documentation>
					(out) Your application has exceeded its daily hard limit.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PeriodicLimitExceeded">
				<xs:annotation>
					<xs:documentation>
					(out) Your application has exceeded its periodic hard limit.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HourlySoftLimitExceeded">
				<xs:annotation>
					<xs:documentation>
					(out) Your application has exceeded its hourly soft limit.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DailySoftLimitExceeded">
				<xs:annotation>
					<xs:documentation>
					(out) Your application has exceeded its daily soft limit.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PeriodicSoftLimitExceeded">
				<xs:annotation>
					<xs:documentation>
					(out) Your application has exceeded its periodic soft limit.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
  					<xs:documentation>
	    			 (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AccessRuleStatusCodeList.xsd #####

-->
	<xs:simpleType name="AccessRuleStatusCodeType">
		<xs:annotation>
				<xs:documentation>
					Defines values that describe an application's current status
					with respect to an API access rule. The rules specify daily,
					hourly, and periodic usage limits for various eBay Web Services calls.
				</xs:documentation>
			</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="RuleOff">
				<xs:annotation>
					<xs:documentation>
						(out) The rule is turned off, and no rule validation
						was performed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RuleOn">
				<xs:annotation>
					<xs:documentation>
						(out) The rule is turned on, and rule validation was
						performed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ApplicationBlocked">
				<xs:annotation>
					<xs:documentation>
						(out) The application is blocked from making
						requests to the call named in this rule.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AccountDetailEntryCodeList.xsd #####

-->
	<xs:simpleType name="AccountDetailEntryCodeType">
		<xs:annotation>
			<xs:documentation>
			  Specifies values that describe a transaction on an account. Details of
			  the transaction are returned in AccountEntry. The transaction can
			  be a debit or credit to the account.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unknown">
				<xs:annotation>
					<xs:documentation>
					 (out) The reason for the charge is unknown.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeInsertion">
				<xs:annotation>
					<xs:documentation>
					  (out) The fee for listing an item for sale on eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeBold">
				<xs:annotation>
					<xs:documentation>
					 (out) The fee for a listing title in boldface font.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeFeatured">
				<xs:annotation>
					<xs:documentation>
					  (out) The fee for adding an optional feature to a listing,
					  such as a reserve fee or a listing upgrade fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeCategoryFeatured">
				<xs:annotation>
					<xs:documentation>
					 (out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeFinalValue">
				<xs:annotation>
					<xs:documentation>
					 (out) The fee charged when a listed item sells. The fee
					 is a percentage of the final sale price.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentCheck">
				<xs:annotation>
					<xs:documentation>
					(out) A payment by check made by a seller to eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentCC">
				<xs:annotation>
					<xs:documentation>
					(out) A payment by credit card made by a seller to eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCourtesy">
				<xs:annotation>
					<xs:documentation>
					 (out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditNoSale">
				<xs:annotation>
					<xs:documentation>
					 (out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditPartialSale">
				<xs:annotation>
					<xs:documentation>
					 (out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RefundCC">
				<xs:annotation>
					<xs:documentation>
					 (out) A refund made by eBay to the seller&apos;s credit card.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RefundCheck">
				<xs:annotation>
					<xs:documentation>
					(out) A refund made by eBay to the seller by check.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FinanceCharge">
				<xs:annotation>
					<xs:documentation>
					(out) A finance charge made to the seller&apos;s account, for example,
					the monthly finance charge added to an account whose balance has not been
					paid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AWDebit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AWCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AWMemo">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditDuplicateListing">
				<xs:annotation>
					<xs:documentation>
					(out) A credit made by eBay for a duplicate listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeePartialSale">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for a partial sale.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentElectronicTransferReversal">
				<xs:annotation>
					<xs:documentation>
					(out) A reversal of an electronic transfer payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentCCOnce">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time payment to the account made by
					credit card.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeReturnedCheck">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for a returned check.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeRedepositCheck">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay when a check must be redeposited
					to collect funds.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentCash">
				<xs:annotation>
					<xs:documentation>
					(out) A cash payment made on the seller&apos;s account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditInsertion">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for an insertion fee.
					If a listed item does not sell or results in an
					Unpaid Item (UPI) dispute, the seller can relist
					the item. If the item sells the second time, eBay
					credits the insertion fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditBold">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the Bold listing fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditFeatured">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the Featured listing fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCategoryFeatured">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditFinalValue">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the Final Value Fee.
					Issued as a result of an Unpaid Item dispute, under
					some circumstances.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeNSFCheck">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay when the seller&apos;s check does not clear
					due to insufficient funds.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeReturnCheckClose">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay when the seller&apos;s check does not clear
					because the account has been closed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Memo">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentMoneyOrder">
				<xs:annotation>
					<xs:documentation>
					(out) A payment made to the account by money order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardOnFile">
				<xs:annotation>
					<xs:documentation>
					(out) An automatic monthly charge of the seller&apos;s invoice
					amount made by eBay to a credit card the seller has placed
					on file.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardNotOnFile">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time payment made by a credit card
					that is not on file with eBay for automatic monthly
					payments.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Invoiced">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InvoicedCreditCard">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditTransferFrom">
				<xs:annotation>
					<xs:documentation>
					(out) A transfer from another account to this account,
					resulting in a credit to this account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DebitTransferTo">
				<xs:annotation>
					<xs:documentation>
					(out) A transfer from this account to another account,
					resulting in a debit to this account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InvoiceCreditBalance">
				<xs:annotation>
					<xs:documentation>
					(out) A credit balance for an account&apos;s invoice period,
					meaning that the seller should not pay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayDebit">
				<xs:annotation>
					<xs:documentation>
					(out) An all-purpose code for debits that are manually applied to auctions,
					for example, when the credit cannot be applied to an item number
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayCredit">
				<xs:annotation>
					<xs:documentation>
					(out) An all-purpose code for credits that are manually applied to auctions,
					for example, when the credit cannot be applied to an item number
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PromotionalCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CCNotOnFilePerCustReq">
				<xs:annotation>
					<xs:documentation>
					(out) A note that the credit card is not
					on file at the customer&apos;s request.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditInsertionFee">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for an insertion
					fee when an item is relisted.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CCPaymentRejected">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeGiftIcon">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for adding a gift icon to
					a listing. The gift icon highlights the item as a good
					gift and might offer gift services, such as wrapping
					or shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditGiftIcon">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the gift item
					fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeGallery">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for listing an item
					in the Picture Gallery. A buyer sees a picture of
					the item when browsing a category, before moving to
					the item&apos;s listing page.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeFeaturedGallery">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for listing an item
					in the Featured section at the top of the Picture Gallery
					page.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditGallery">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the Gallery fee
					charged when the item was listed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditFeaturedGallery">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the Featured Gallery
					fee charged when the item was listed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemMoveFee">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OutageCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay when listings are not available
					due to system downtime. The downtime can be a title search
					outage or a hard outage. See the online help for details.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditPSA">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditPCGS">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeReserve">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay when an item is listed with
					a reserve price. The fee is credited when the auction
					completes successfully.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditReserve">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for a reserve price auction
					when the auction completes successfully.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayVISACredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BBAdminCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BBAdminDebit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReferrerCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay to a Store owner
					who has promoted items outside of eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReferrerDebit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SwitchCurrency">
				<xs:annotation>
					<xs:documentation>
					(out) A switch from one billing currency to another.
					The billing currency can be USD, EUR, CAD, GBP, AUD,
					JPY, or TWD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentGiftCertificate">
				<xs:annotation>
					<xs:documentation>
					(out) A payment made to the account by gift certificate.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentWireTransfer">
				<xs:annotation>
					<xs:documentation>
					(out) A payment made to the account by wire transfer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentHomeBanking">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentElectronicTransfer">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time payment made to the account by electronic
					transfer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentAdjustmentCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit (addition) made by eBay to the seller&apos;s account
					when a payment needs to be adjusted.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentAdjustmentDebit">
				<xs:annotation>
					<xs:documentation>
					(out) A debit (deduction) made by eBay to the seller&apos;s account
					when a payment needs to be adjusted.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Chargeoff">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeoffRecovery">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeoffBankruptcy">
				<xs:annotation>
					<xs:documentation>
					(out) A writeoff of the account charge by eBay
					because the seller has declared bankruptcy.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeoffSuspended">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeoffDeceased">
				<xs:annotation>
					<xs:documentation>
					(out) A writeoff of the account charge by eBay
					because the seller is deceased.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeoffOther">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeoffWacko">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FinanceChargeReversal">
				<xs:annotation>
					<xs:documentation>
					(out) A reversal of a finance charge, made by eBay.
					The finance charge is added if the seller does not pay
					the monthly account balance on time.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FVFCreditReversal">
				<xs:annotation>
					<xs:documentation>
					(out) A reversal of a Final Value Fee credit, resulting
					in the fee being charged to the seller. The Final Value
					Fee can be credited as a result of an Unpaid Item Dispute.
					If the buyer later pays, the seller can request a reversal.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ForeignFundsConvert">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for currency conversion.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ForeignFundsCheckReversal">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EOMRestriction">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllFeesCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SetOnHold">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RevertUserState">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebitOnFile">
				<xs:annotation>
					<xs:documentation>
					(out) A monthly payment made by automatic direct debit to the
					seller&apos;s checking account, when the account information
					is on file.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebitNotOnFile">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time payment made by direct debit to the seller&apos;s
					checking account, when the account information is not on file,
					but is provided for this payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentDirectDebit">
				<xs:annotation>
					<xs:documentation>
					(out) A payment made by direct debit from the seller&apos;s
					checking account when the seller has requested automatic
					monthly invoice payments.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebitReversal">
				<xs:annotation>
					<xs:documentation>
					(out) A reversal of a payment made by direct debit
					from the seller&apos;s checking account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebitReturnedItem">
				<xs:annotation>
					<xs:documentation>
					(out) A reversal of a payment made by direct debit
					from a seller&apos;s checking account when an item is returned
					by the buyer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeHighlight">
				<xs:annotation>
					<xs:documentation>
					 (out) A fee charged by eBay for adding a colored band to
					 emphasize a listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditHighlight">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for a highlight fee on an
					item&apos;s listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BulkUserSuspension">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeRealEstate30DaysListing">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for a 30-day real estate
					listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditRealEstate30DaysListing">
				<xs:annotation>
					<xs:documentation>
					(out) A credit for a 30-day real estate listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TradingLimitOverrideOn">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TradingLimitOverrideOff">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EquifaxRealtimeFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged to sellers who do not provide a credit card
					or checking account number to verify identify.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditEquifaxRealtimeFee">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for an EquifaxRealtimeFee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentEquifaxDebit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentEquifaxCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Merged">
				<xs:annotation>
					<xs:documentation>
					(out) Two accounts with the same owner but different user IDs
					have been merged into one.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AutoTraderOn">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AutoTraderOff">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaperInvoiceOn">
				<xs:annotation>
					<xs:documentation>
					(out) The option to send the seller paper invoices
					has been turned on.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaperInvoiceOff">
				<xs:annotation>
					<xs:documentation>
					(out) The option to send the seller paper invoices
					has been turned off.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountStateSwitch">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FVFCreditReversalAutomatic">
				<xs:annotation>
					<xs:documentation>
					(out) An automatic reversal of a Final Value Fee
					credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditSoftOutage">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted by eBay when a title search
					outage of one hour or longer occurs on the site.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LACatalogFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for listing a lot (one or more items) in a
					Live Auction catalog.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAExtraItem">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for listing an extra item in a Live Auction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LACatalogItemFeeRefund">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LACatalogInsertionRefund">
				<xs:annotation>
					<xs:documentation>
					(out) A credit for listing an item in a Live Auction catalog.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAFinalValueFee">
				<xs:annotation>
					<xs:documentation>
					(out) A Final Value Fee charged by eBay when a lot listed
					on a Live Auction is sold.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAFinalValueFeeRefund">
				<xs:annotation>
					<xs:documentation>
					(out) A refund of a Final Value Fee that was charged
					when a Live Auction lot was sold.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LABuyerPremiumPercentageFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee paid by the buyer to the auction house for
					a purchase in a Live Auction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LABuyerPremiumPercentageFeeRefund">
				<xs:annotation>
					<xs:documentation>
					(out) A refund of the fee paid by a buyer to the auction
					house for a purchase in a Live Auction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAAudioVideoFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for audio or video services provided
					during the sale of lots at a Live Auction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LAAudioVideoFeeRefund">
				<xs:annotation>
					<xs:documentation>
					(out) A refund for audio or video services provided at
					a Live Auction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeIPIXPhoto">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for a panoramic 360-degree photo
					in a listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeIPIXSlideShow">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for a slide show of panoramic 360-degree
					photos.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditIPIXPhoto">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted to reverse an IPIX photo fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditIPIXSlideShow">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted to reverse an IPIX slideshow fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeTenDayAuction">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for listing an item for 10 days,
					rather than one, three, five, or seven days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditTenDayAuction">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted to reverse a 10-day auction
					fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TemporaryCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TemporaryCreditReversal">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubscriptionAABasic">
				<xs:annotation>
					<xs:documentation>
				      (out) A fee charged for a subscription to Auction Assistant Basic.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubscriptionAAPro">
				<xs:annotation>
					<xs:documentation>
				      (out) A fee charged for a subscription to Auction Assistant Pro.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditAABasic">
				<xs:annotation>
					<xs:documentation>
				     (out) A credit granted for a subscription fee charged for Auction Assistant Basic.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditAAPro">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for a subscription fee charged for Auction Assistant Pro.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeLargePicture">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for a supersized picture
					in a listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditLargePicture">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for a supersized picture.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeePicturePack">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for the Picture Pack feature.
					The fee differs according to the number of pictures you
					use. See the online help for details.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditPicturePackPartial">
				<xs:annotation>
					<xs:documentation>
					 (out) A partial credit issued by eBay for the Picture Pack fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditPicturePackFull">
				<xs:annotation>
					<xs:documentation>
					 (out) A full credit issued by eBay for the Picture Pack fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubscriptioneBayStores">
				<xs:annotation>
					<xs:documentation>
					 (out) A monthly subscription fee charged for an eBay Store.
					  The fee can be Basic, Featured, or Anchor.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CrediteBayStores">
				<xs:annotation>
					<xs:documentation>
					 (out) A credit issued by eBay for the monthly fee charged
					 for an eBay store.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeInsertionFixedPrice">
				<xs:annotation>
					<xs:documentation>
					(out) The fee charged by eBay for listing a Fixed Price item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditInsertionFixedPrice">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for listing a Fixed Price item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeFinalValueFixedPrice">
				<xs:annotation>
					<xs:documentation>
					 (out) The Final Value Fee credit charged by eBay when
					 a fixed price item sells.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditFinalValueFixedPrice">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the Final Value Fee
					for a fixed price item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ElectronicInvoiceOn">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ElectronicInvoiceOff">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlagDDDDPending">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlagDDPaymentConfirmed">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPriceDurationFee">
				<xs:annotation>
					<xs:documentation>
					(out) The fee charged by eBay for creating a Fixed Price
					listing with a 10-day duration. Fixed Price listings
					of 1, 3, 5, and 7 days are not charged this fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPriceDurationCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for a Fixed Price listing
					with a 10-day duration.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyItNowFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for listing a Buy It Now item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyItNowCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for the fee charged for a
					Buy It Now listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeSchedule">
				<xs:annotation>
					<xs:documentation>
					(out) A fee for scheduling a listing to start at some
					later time, up to 3 weeks after the listing is created.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditSchedule">
				<xs:annotation>
					<xs:documentation>
					(out) A credit made by eBay for the fee charged for
					scheduling a listing to start after the listing is created.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubscriptionSMBasic">
				<xs:annotation>
					<xs:documentation>
					 (out) The monthly subscription fee charged for
					 Selling Manager Basic. The monthly charge is billed
					 in advance.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubscriptionSMBasicPro">
				<xs:annotation>
					<xs:documentation>
					(out) The monthly subscription fee charged for
					Selling Manager Pro. The monthly charge is billed
					in advance.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditSMBasic">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time credit for a free one-month
					trial of Selling Manager Basic.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditSMBasicPro">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time credit for a free one-month
					trial of Selling Manager Pro.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresGTCFee">
				<xs:annotation>
					<xs:documentation>
					(out) The fee charged for a Good-Til-Cancelled
					listing in an eBay Store. The charge is made once
					each 30 days, until the listing ends.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresGTCCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit for the fee charged for a Good-Til-Cancelled
					listing in an eBay Store.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ListingDesignerFee">
				<xs:annotation>
					<xs:documentation>
					(out) The fee charged for using a Listing Designer theme and layout
					template for a listing. The fee is displayed to the seller during
					the listing process.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ListingDesignerCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit issued by eBay for a Listing Designer fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExtendedAuctionFee">
				<xs:annotation>
					<xs:documentation>
					(out) The fee charged for listing an auction item
					for 10 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExtendedAcutionCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit for the fee charged for listing an
					auction item for 10 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalOTPSucc">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalOTPPend">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalFailed">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalChargeBack">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeBack">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeBackReversal">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalRefund">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BonusPointsAddition">
				<xs:annotation>
					<xs:documentation>
					(out) An addition to the seller&apos;s eBay
					Anything Points account. Each point is
					equivalent to $0.01.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BonusPointsReduction">
				<xs:annotation>
					<xs:documentation>
					(out) A reduction to the seller&apos;s eBay
					Anything Points account. Each point is
					equivalent to $0.01.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BonusPointsPaymentAutomatic">
				<xs:annotation>
					<xs:documentation>
					(out) An automatic payment of seller fees
					from the seller&apos;s eBay Anything Points account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BonusPointsPaymentManual">
				<xs:annotation>
					<xs:documentation>
					(out) A one-time payment of seller fees from
					the seller&apos;s eBay Anything Points account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BonusPointsPaymentReversal">
				<xs:annotation>
					<xs:documentation>
					(out) A reversal of a seller fee payment made
					from the seller&apos;s eBay Anything Points account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BonusPointsCashPayout">
				<xs:annotation>
					<xs:documentation>
					(out) A cash payment made from the seller&apos;s eBay
					Anything Points account and credited to the seller&apos;s
					account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit (return) to your account of Value-Added Tax
					previously paid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATDebit">
				<xs:annotation>
					<xs:documentation>
					 (out) A debit to your account for a Value-Added Tax charge.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATStatusChangePending">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATStatusChangeApproved">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATStatusChange_Denied">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATStatusDeletedByCSR">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATStatusDeletedByUser">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SMProListingDesignerFee">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SMProListingDesignerCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresSuccessfulListingFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for the difference between an eBay Store inventory listing
					fee and an auction listing fee if a Store inventory item sells.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresSuccessfulListingFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit for a StoresSuccessfulListingFee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresReferralFee">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresReferralCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit posted to a seller&apos;s account
					for sale of Stores Inventory items by buyers
					referred to the seller&apos;s Store by printed materials
					and emails outside eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubtitleFee">
				<xs:annotation>
					<xs:documentation>
					(out) The fee charged for adding a subtitle
					to a listing. The subtitle adds information
					to the title.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SubtitleFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit of the fee charged for adding a
					subtitle to a listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayStoreInventorySubscriptionCredit">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AutoPmntReqExempt">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AutoPmntReqRein">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerSubscriptionFee">
				<xs:annotation>
					<xs:documentation>
					(out) The monthly fee charged for subscribing to
					Picture Manager. The fee varies according to
					the level of subscription.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerSubscriptionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for a Picture Manageer subscription
					fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReportsBasicFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for a basic subscription to Seller Reports.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReportsBasicCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for a basic subscription to Seller Reports.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReportsPlusFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for a subscription to Seller Reports Plus.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReportsPlusCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for a subscription to Seller Reports Plus.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaypalOnFile">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaypalOnFileByCSR">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaypalOffFile">
				<xs:annotation>
					<xs:documentation>
					(out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BorderFee">
				<xs:annotation>
					<xs:documentation>
					(out) The fee for adding a border that outlines a listing with a frame.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BorderFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit for the border fee charged for a listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeSearchableMobileDE">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged to a seller for upgrading
					a listing from eBay Germany&apos;s Car, Motorcycle,
					and Special Vehicle categories so that it is also
					searchable on the mobile.de classifieds site.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SalesReportsPlusFee">
				<xs:annotation>
					<xs:documentation>
					(out) A monthly subscription fee charged for
					Sales Reports Plus.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SalesReportsPlusCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for a Sales Reports Plus
					monthly subscription fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditSearchableMobileDE">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for upgrading a listing
					to make it searchable on the mobile.de platform.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EmailMarketingFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged to owners of eBay Stores
					who have a sent a marketing email to buyers,
					for the number of email recipients over
					the Store&apos;s monthly free allocation. The
					monthly allocation varies according to the type
					of Store.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EmailMarketingCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for an email marketing fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeePictureShow">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for the Picture Show
					service, which lets buyers browse or see a slide
					show of 2 or more pictures at the top of the
					item page.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditPictureShow">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted for a Picture Show fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackBundleFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged for the ProPackBundle feature pack (currently available to US and Canada eBay motor vehicle sellers).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackBundleFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted by eBay for the ProPackBundle feature pack (currently available to US and Canada eBay motor vehicle sellers).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicUpgradePackBundleFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for the BasicUpgradePackBundle feature pack. Australia site (site ID 15, abbreviation AU) only. Effective beginning February 22, 2006.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicUpgradePackBundleFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted by eBay for the BasicUpgradePackBundle feature pack. Australia site (site ID 15, abbreviation AU) only. Effective beginning February 22, 2006.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ValuePackBundleFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for the ValuePackBundle feature pack. Effective beginning February 22, 2006.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ValuePackBundleFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted by eBay for the ValuePackBundle feature pack. Effective beginning February 22, 2006.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackPlusBundleFee">
				<xs:annotation>
					<xs:documentation>
					(out) A fee charged by eBay for the ProPackPlusBundle feature pack. Effective beginning February 22, 2006.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackPlusBundleFeeCredit">
				<xs:annotation>
					<xs:documentation>
					(out) A credit granted by eBay for the ProPackPlusBundle feature pack. Effective beginning February 22, 2006.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FinalEntry">
				<xs:annotation>
					<xs:documentation>
					(out) The final entry in an account before it is closed
					or merged with another account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					(out) Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExtendedDurationFee">
				<xs:annotation>
					<xs:documentation>
						(out) A fee charged for extended listing duration.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExtendedDurationFeeCredit">
				<xs:annotation>
					<xs:documentation>
						(out) A credit granted by eBay for extended listing duration.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InternationalListingFee">
				<xs:annotation>
					<xs:documentation>
					  (out) The fee for an international listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InternationalListingCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A credit issued by eBay for an international listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarketplaceResearchExpiredSubscriptionFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A MarketPlace Research fee for expired subscriptions.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarketplaceResearchExpiredSubscriptionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A MarketPlace Research credit for expired subscriptions.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarketplaceResearchBasicSubscriptionFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A MarketPlace Research basic subscription fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarketplaceResearchBasicSubscriptionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A MarketPlace Research basic subscription credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarketplaceResearchProSubscriptionFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A MarketPlace Research pro subscription fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicBundleFee">
				<xs:annotation>
					<xs:documentation>
					  (out) Basic bundle fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicBundleFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) Basic bundle fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarketplaceResearchProSubscriptionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A MarketPlace Research pro subscription fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalSubscriptionFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local subscription fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalSubscriptionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local subscription fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalInsertionFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local insertion fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalInsertionFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local insertion fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalFinalValueFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local final value fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalFinalValueFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local final value fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalGTCFee">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local GTC fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VehicleLocalGTCFeeCredit">
				<xs:annotation>
					<xs:documentation>
					  (out) A Vehicle Local GTC fee credit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeeGalleryPlus">
				<xs:annotation>
					<xs:documentation>
						(out) A fee charged by eBay for listing an item with the
						Gallery Plus feature enabled. This feature cannot be removed
						with ReviseItem or RelistItem. However, if the feature is
						upgraded, for example, to Gallery Featured, the fee for
						Gallery Plus is refunded and a fee for Gallery Feature is
						charged instead.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditGalleryPlus">
				<xs:annotation>
					<xs:documentation>
						(out) A credit issued by eBay when refunding the fee for
						enabling the Gallery Plus feature. A Gallery Plus credit may
						be issued if, for example, a user upgrades their feature
						with ReviseItem or RelistItem to Gallery Featured. In this
						case, the original Gallery Plus fee is refunded and a
						Gallery Featured fee is charged instead.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AccountEntriesType.xsd #####

-->
	<xs:complexType name="AccountEntriesType">
		<xs:annotation>
			<xs:documentation> 
        Collection of zero, one, or multiple individual detail account entries. Contains
        one AccountEntry object for each account entry returned. See the schema
        documentation for AccountEntryType for details on its properties. You can uniquely identify
        the entries that the GetAccount call returns within the AccountEntries tag.
        Specifically, the following fields, returned within the AccountEntries tag,
        can be used in combination as a unique key: AccountEntry.Date, AccountEntry.AccountDetailsEntryType,
        AccountEntry.ItemID, and AccountEntry.RefNumber. 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AccountEntry" type="ns:AccountEntryType"  minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
                Contains the data for one account entry. (See the schema
                documentation for AccountEntryType for details on its properties.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AccountEntrySortTypeCodeList.xsd #####

-->
	<xs:simpleType name="AccountEntrySortTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			  Specifies how account entries should be sorted in a response
			  from eBay.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
					 (in) Sort by the AccountEntry.Date value in the response,
					 in ascending order. Same as AccountEntryCreatedTimeAscending.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountEntryCreatedTimeAscending">
				<xs:annotation>
					<xs:documentation>
					 (in) Sort by the AccountEntry.Date value in the response,
					 in ascending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountEntryCreatedTimeDescending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the AccountEntry.Date value in the response, in
					descending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountEntryItemNumberAscending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the AccountEntry.ItemID value in the response, in
					ascending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountEntryItemNumberDescending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the AccountEntry.ItemID value in the response,
					in descending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountEntryFeeTypeAscending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the value returned in AccountEntry.Description,
					with entries starting with lowercase letters before entries starting
					with uppercase letters and each group in alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountEntryFeeTypeDescending">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the value returned in AccountEntry.Description, with entries 
					starting with uppercase letters before entries starting with lowercase
					letters and each group in reverse alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                    (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AccountEntryType.xsd #####

-->
	<xs:complexType name="AccountEntryType">
		<xs:annotation>
			<xs:documentation>
        Contains the data for a single account detail entry. Each detail entry is a
        transaction posted to the account and may be: a credit, a debit, or an
        administrative action (such as an update putting a credit card on file for
        the account). You can uniquely identify
        the entries that the GetAccount call returns within the AccountEntries tag.
        Specifically, the following fields, returned within the AccountEntries tag,
        can be used in combination as a unique key: AccountEntry.Date, AccountEntry.AccountDetailsEntryType,
        AccountEntry.ItemID, and AccountEntry.RefNumber.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AccountDetailsEntryType" type="ns:AccountDetailEntryCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the type of transaction or reason for the transaction. For example,
						a value of FeeGallery indicates a debit for listing an item in the Gallery.
						Possible values are enumerated in the AccountDetailEntryCodeType code list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
				  A description of the transaction. Returned with compatibility
				  level 387.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Balance" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Balance after the account entry's credit or debit amount has been applied.
                Can be 0.00. With compatibility level 387, the value is positive for debits
				and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Credit" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Credit amount for a detail entry. Will be 0.00 if the entry is a debit.
                Obsolete (not returned) with compatibility level 387 and higher.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Obsolete</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Date" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Date entry was posted to the account, in GMT. (Also see the Data Types
                appendix for more information on how GMT dates are handled in SOAP.)
					</xs:documentation>
						<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Debit" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Debit amount for this detail entry. Will be 0.00 if the entry is a credit.
				Obsolete (not returned) with compatibility level 387 and higher.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Obsolete</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GrossDetailAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Gross fees that are assessed by eBay (net fees plus VAT, if any).
				Returned even if VAT does not apply.
				With compatibility level 387, the value is positive for debits
				and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Item ID (if the account detail entry is associated with an item listing) or
						0 (if no item listing is associated with the account entry).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Memo" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Memo line for the account entry, can be an empty string.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NetDetailAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Net fees that are assessed by eBay, excluding additional surcharges and VAT (if any).
				Returned even if VAT does not apply.
				With compatibility level 387, the value is positive for debits
				and negative for credits, reversing the sign of earlier versions.
 					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RefNumber" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                eBay reference number for the account entry. May return no value for some
                account transactions, such as an administrative action like placing the
                user's credit card on file.  You can uniquely identify
				        the entries that the GetAccount call returns within the AccountEntries tag.
				        Specifically, the following fields, returned within the AccountEntries tag,
				        can be used in combination as a unique key: AccountEntry.Date, AccountEntry.AccountDetailsEntryType,
				        AccountEntry.ItemID, and AccountEntry.RefNumber.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VATPercent" type="xs:decimal" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						VAT rate for the item. When the VATPercent is specified, the
						item's VAT information appears on the item's listing page. In
						addition, the seller can choose to print an invoice that
						includes the item's net price, VAT percent, VAT amount, and
						total price. Since VAT rates vary
						depending on the item and on the user's country of residence, a
						seller is responsible for entering the correct VAT rate; it is
						not calculated by eBay. To specify a VATPercent, a seller must
						have a VAT-ID registered with eBay and must be listing the item
						on a VAT-enabled site. Max precision 3
						decimal places. Max length 5 characters. Note: The View Item
						page displays the precision to 2 decimal places with no
						trailing zeros. However, the full value you send in is stored.
						Returned for all users, not just VAT users, with GetAccountResponse.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Title of the entry.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AccountHistorySelectionCodeList.xsd #####

-->
	<xs:simpleType name="AccountHistorySelectionCodeType">
		<xs:annotation>
			<xs:documentation>
             Specifies a report format to be used to describe the seller's account.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="LastInvoice">
				<xs:annotation>
					<xs:documentation>
                 (in) Contains the entries since the last invoice eBay sent to the seller.
				 With LastInvoice, InvoiceDate, BeginDate and EndDate (in GetAccountRequest) 
				 are ignored.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SpecifiedInvoice">
				<xs:annotation>
					<xs:documentation>
                (in) Contains the entries for a
                specific invoice, identified by the invoice month and year.
				With SpecifiedInvoice, you must specify InvoiceDate in GetAccountRequest.
				However, BeginDate and EndDate are ignored.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BetweenSpecifiedDates">
				<xs:annotation>
					<xs:documentation>
                (in) Contains entries that were posted to the seller's account between two dates.
                The period covered may cross the boundaries of formal invoices.
				With BetweenSpecifiedDates, you must specify BeginDate and EndDate in 
				GetAccountRequest. However, InvoiceDate is ignored.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AccountStateCodeList.xsd #####

-->
	<xs:simpleType name="AccountStateCodeType">
		<xs:annotation>
			<xs:documentation>
				State of an account of an eBay user.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
						(out) The account is active.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						(out) The account has been created but is not yet active,
						pending additional information or processing by eBay.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Inactive">
				<xs:annotation>
					<xs:documentation>
						(out) The account is inactive. No new seller account entries
						would be posted by eBay to the account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AccountSummaryType.xsd #####

-->
	<xs:complexType name="AccountSummaryType">
		<xs:annotation>
			<xs:documentation>
				Summary data for the requesting user's seller account as a whole. This includes a
				balance for the account, any past due amount and date, and defining data for
				additional accounts (if the user has changed country of residency while having an
				active eBay account).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AccountState" type="ns:AccountStateCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the current state of the account (such as active or inactive).
						Possible values are enumerated in the AccountStateCodeType code list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvoicePayment" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies payment made since the previous invoice, but is
						returned only if AccountHistorySelection is LastInvoice or Specified
						Invoice. With compatibility level 387, the value is positive for
						debits and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvoiceCredit" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies credits granted since the previous invoice, but
						is only returned AccountHistorySelection is LastInvoice or Specified
						Invoice.
						With compatibility level 387, the value is positive for debits
						and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvoiceNewFee" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies fees incurred since the last invoice, including
						tax if applicable. Returned only if AccountHistorySelection
						is LastInvoice or Specified Invoice. With compatibility level 387,
						the value is positive for debits and negative for credits, reversing
						the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AdditionalAccount" type="ns:AdditionalAccountType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
                Contains the data for one additional account. An AccountSummaryType object
                may return zero, one, or multiple additional accounts. See the schema
                documentation for AdditionalAccountType for details on additional accounts.
                With compatibility level 387, the value is positive for debits
                and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AmountPastDue" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount past due, 0.00 if not past due.
						With compatibility level 387, the value is positive for debits
						and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BankAccountInfo" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						First four digits of the bank account the user associated with the seller
						account (with remainder Xed-out). This may be an empty string depending
						upon the payment type the user selected for the account (e.g., if no
						debit-card specified).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>4</MaxLength>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BankModifyDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the date and time BankAccountInfo was last modified, in GMT.
						(Also see the Data Types appendix for more information on how GMT dates are
						handled in SOAP.) This may be an empty string depending upon the payment
						type the user selected for the account (e.g., if no debit-card specified).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BillingCycleDate" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the billing cycle in which eBay sends a billing invoice to the
						user. A value of 0 (zero) indicates an invoice sent on the last day of the
						month. A value of 15 indicates an invoice sent on the 15th day of the
						month.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreditCardExpiration" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Expiration date for the credit card selected by the user as payment method
						for the account, in GMT. (Also see the Data Types appendix for more
						information on how GMT dates are handled in SOAP.) Empty string if no
						credit card is on file or if the account is inactive - even if there is a
						credit card on file.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreditCardInfo" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Last four digits of the credit card the user selected as payment method for
						the account. Empty string if no credit is on file.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreditCardModifyDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the date and time credit card or credit card expiration date was
						last modified, in GMT. (Also see the Data Types appendix for more
						information on how GMT dates are handled in SOAP.) This may be an empty
						string depending on the payment method the user selected for the account
						(e.g., Empty string if no credit card is on file.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CurrentBalance" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Current balance for the account. Can be 0.00, positive, or negative.
						With compatibility level 387, the value is positive for debits
						and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Email" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Email address for the user.
						You cannot retrieve an email address for any user with whom
						you do not have a transactional relationship, regardless of
						site. Email is only returned for applicable calls when you
						are retrieving your own user data OR when you and the other
						user are in a transactional relationship and the call is
						being executed within a certain amount of time after the
						transaction is created.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvoiceBalance" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount of last invoice. 0.00 if account not yet invoiced.
						With compatibility level 387, the value is positive for debits
						and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InvoiceDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date of last invoice sent by eBay to the user, in GMT. (Also see the Data
						Types appendix for more information on how GMT dates are handled in SOAP.)
						Empty string if this account has not been invoiced yet.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastAmountPaid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount of last payment posted, 0.00 if no payments posted.
						With compatibility level 387, the value is positive for debits
						and negative for credits, reversing the sign of earlier versions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastPaymentDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date of last payment by the user to eBay, in GMT. (Also see the Data Types
						appendix for more information on how GMT dates are handled in SOAP.) Empty
						string if no payments have been posted.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PastDue" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the account has past due amounts outstanding. A value of
						true indicates that the account is past due. A value of false indicates the
						account is current.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentMethod" type="ns:SellerPaymentMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the method the user selected to pay eBay with for the account.
						The values for PaymentMethod vary from one global eBay site to the next.
						Payment methods are enumerated in the SellerPaymentMethodCodeType code
						list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AdFormatEnabledCodeList.xsd #####

-->
	<xs:simpleType name="AdFormatEnabledCodeType">
		<xs:annotation>
			<xs:documentation>
				Used to indicate whether the Ad Format feature is enabled for a category. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Disabled">
				<xs:annotation>
					<xs:documentation>
						The Ad Format feature is disabled for the category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Enabled">
				<xs:annotation>
					<xs:documentation>
						The Ad Format feature is enabled for the category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Only">
				<xs:annotation>
					<xs:documentation>
						The category supports the Ad Format feature only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClassifiedAdEnabled">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
				  </xs:documentation>
				  <xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClassifiedAdOnly">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
				  </xs:documentation>
				  <xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AdFormatEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="AdFormatEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the AdFormatEnabled feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (e.g., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AdFormatLeadType.xsd #####

-->
	<xs:complexType name="AdFormatLeadType">
		<xs:annotation>
			<xs:documentation>
			(out) Contains contact and other information for one lead.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AdditionalInformation" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) Additional information that the lead wants to tell the seller. Not returned if information is unavailable.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Address" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) Address information for the lead. Not returned if information is unavailable.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestTimeToCall" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) The time of day when the lead prefers the seller to contact him or her. Not returned if information is unavailable.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Email" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Email address for the lead.
						You cannot retrieve an email address for any user with whom 
						you do not have a transactional relationship, regardless of 
						site. Email is only returned for applicable calls when you 
						are retrieving your own user data OR when you and the other 
						user are in a transactional relationship and the call is 
						being executed within a certain amount of time after the 
						transaction is created.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FirstName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) First name of the lead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) Last name of the lead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Phone" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) Phone number of the lead. Not returned if information is unavailable.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SubmittedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(out) Date and time (in GMT) that the lead was submitted.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAdFormatLeads</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AddMemberMessagesAAQToBidderRequestContainerType.xsd #####

-->
	<xs:complexType name="AddMemberMessagesAAQToBidderRequestContainerType">
		<xs:annotation>
			<xs:documentation>
				Holds the content of the request.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CorrelationID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Use to track that a response is returned for every
						request and to match particular responses to
						particular requests.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddMemberMessagesAAQToBidder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						An eBay ID that uniquely identifies a given
						item. Must be a currently active item.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>AddMemberMessagesAAQToBidder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MemberMessage" type="ns:MemberMessageType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Holds the content of the message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddMemberMessagesAAQToBidder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AddMemberMessagesAAQToBidderResponseContainerType.xsd #####

-->
	<xs:complexType name="AddMemberMessagesAAQToBidderResponseContainerType">
		<xs:annotation>
			<xs:documentation>
				Contains the response information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CorrelationID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Use to track that a response is returned for every
						request and to match particular responses to
						particular requests.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddMemberMessagesAAQToBidder</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Ack" type="ns:AckCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the response status (e.g., success).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddMemberMessagesAAQToBidder</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AdditionalAccountType.xsd #####

-->
	<xs:complexType name="AdditionalAccountType">
		<xs:annotation>
			<xs:documentation>
            Contains the data for one additional account. An additional account is
            created when the user has an active account and changes country of
            registry (i.e., registers with the eBay site for the new country). A
            new account is created and the old account becomes inactive as an
            additional account. A user who never changes country of residency while
            having an account will never have any additional accounts.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Balance" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Indicates the current balance of the additional account.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Indicates the currency in which monetary amounts for the additional account
                are expressed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AccountCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
                Indicates the unique identifier for the additional account (the account ID).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AddressOwnerCodeList.xsd #####

-->
	<xs:simpleType name="AddressOwnerCodeType">
		<xs:annotation>
			<xs:documentation>
				Indicates who owns the user's address.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="PayPal">
				<xs:annotation>
					<xs:documentation>
						(in/out) PayPal owns the address.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBay">
				<xs:annotation>
					<xs:documentation> 
						(in/out) eBay owns the address.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AddressRecordTypeCodeList.xsd #####

-->
	<xs:simpleType name="AddressRecordTypeCodeType">
		<xs:annotation>
			<xs:documentation>
           AddressRecordTypeCodeType - Type declaration to be used by other schemas.
           Codes indicate the address type.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Residential">
			</xs:enumeration>
			<xs:enumeration value="Business"/>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AddressStatusCodeList.xsd #####

-->
	<xs:simpleType name="AddressStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				PayPal address status.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None"/>
			<xs:enumeration value="Confirmed"/>
			<xs:enumeration value="Unconfirmed"/>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/AddressType.xsd #####

-->
	<xs:complexType name="AddressType">
	<xs:annotation>
		<xs:documentation>
			Contains the data for one user address. This is the base type for a
			number of user addresses, including seller payment address, buyer
			shipping address and buyer and seller registration address.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="Name" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					User's name for the address.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>64</MaxLength>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetUserContactDetails</CallName>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Street" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					A concatenation of Street1 and Street2 (only for the
					RegistrationAddress instance of AddressType).
					Not applicable to Half.com. Output only.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Street1" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Line 1 of the user's address.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>64</MaxLength>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetAdFormatLeads</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Street2" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Line 2 of the user's address. Returned if applicable.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>64</MaxLength>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CityName" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The name of the user's city.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>64</MaxLength>
					<CallInfo>
						<CallName>GetAdFormatLeads</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<CallName>GetUserContactDetails</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="County" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="StateOrProvince" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The region of the user's address.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>64</MaxLength>
					<CallInfo>
						<CallName>GetAdFormatLeads</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<CallName>GetUserContactDetails</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Country" type="ns:CountryCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The country code of the user.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetUserPreferences</CallName>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<Context>HighBidder</Context>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>ShippingAddress</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetHighBidders</CallName>
						<CallName>GetOrders</CallName>
						<CallName>GetUserContactDetails</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>SetUserPreferences</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CountryName" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The name of the user's country.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Phone" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					User's primary phone number.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<CallName>GetUserContactDetails</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PhoneCountryCode" type="ns:CountryCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PhoneCountryPrefix" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PhoneAreaOrCityCode" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PhoneLocalNumber" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<!-- phone number set 2 -->
		<xs:element name="Phone2CountryCode" type="ns:CountryCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Phone2CountryPrefix" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Phone2AreaOrCityCode" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Phone2LocalNumber" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PostalCode" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					User's postal code.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>12</MaxLength>
					<CallInfo>
						<CallName>GetAdFormatLeads</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<Context>HighBidder</Context>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>ShippingAddress</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
						<Context>SellerPaymentAddress</Context>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Conditionally</Returned>
						<Context>SoldList</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetHighBidders</CallName>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="AddressID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					ID assigned to the address in the eBay database.
					For GetOrders, applies only to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="AddressOwner" type="ns:AddressOwnerCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The realm to which the address belongs (e.g. eBay vs PayPal).
					For GetOrders, applies only to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="AddressStatus" type="ns:AddressStatusCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					PayPal address status.
					Not applicable to Half.com.
				</xs:documentation>
			</xs:annotation>
		</xs:element>
		<xs:element name="ExternalAddressID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					ID assigned to the address by the owner of the address (fitting
					only if the address is owned by PayPal; see AddressOwner).
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>20</MaxLength>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InternationalName" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Seller's international name that is associated with the payment address.
					Only applicable to SellerPaymentAddress.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>SellerPaymentAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InternationalStateAndCity" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					International state and city for the seller's payment address.
					Only applicable to SellerPaymentAddress.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>SellerPaymentAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InternationalStreet" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Seller's international street address that is associated with the payment address.
					Only applicable to SellerPaymentAddress.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<Context>SellerPaymentAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CompanyName" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					User's company name. Only returned if available.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserContactDetails</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<Context>ShippingAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<Context>RegistrationAddress</Context>
					</CallInfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="AddressRecordType" type="ns:AddressRecordTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Indicates the nature of the address (e.g., residential or business).
					Not applicable to Half.com.
				</xs:documentation>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AmountType.xsd #####

-->
	<xs:complexType name="AmountType">
	<xs:annotation>
		<xs:documentation>
			Basic type for specifying monetary amounts. A double value (e.g.,
			1.00 or 1.0) is meaningful as a monetary amount when accompanied by a
			specification of the currency, in which case the value specifies
			the amount in that currency. An AmountType expresses both the value
			(a double) and the currency. Details such as prices, fees, costs,
			and payments are specified as amount types.
		</xs:documentation>
	</xs:annotation>
	<xs:simpleContent>
		<xs:extension base="xs:double">
			<xs:attribute name="currencyID" type="ns:CurrencyCodeType" use="required">
				<xs:annotation>
					<xs:documentation>
						Currency in which the monetary amount is specified.
						Note that SendInvoice does not support this attribute for
						ShippingInsuranceCost, ShippingServiceCost, ShippingServiceAdditionalCost,
						SalesTaxAmount, and InsuranceFee.
					</xs:documentation>
					<xs:appinfo>
						<!-- N/A to several SendInvoice input fields -->
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<Context>TotalWinningCost</Context>
							<Context>TotalWonCost</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOffer</Context>
							<Context>BuyItNowPrice</Context>
							<Context>ConvertedMaxBid</Context>
							<Context>CurrentPrice</Context>
							<Context>MaxBid</Context>
							<Context>SecondChanceOffer</Context>
							<Context>ShippingServiceCost</Context>
							<Context>StartPrice</Context>
							<Context>Subtotal</Context>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>RespondToBestOffer</CallName>
							<CallName>ReviseCheckoutStatus</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>GetOrders</CallName>
							<ExcludeFromContext>InternationalShippingServiceOption</ExcludeFromContext>
							<ExcludeFromContext>ShippingServiceOptions</ExcludeFromContext>
							<ExcludeFromContext>ShippingServiceSelected</ExcludeFromContext>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<ExcludeFromContext>InternationalShippingServiceOption</ExcludeFromContext>
							<ExcludeFromContext>ShippingServiceOptions</ExcludeFromContext>
							<ExcludeFromContext>ShippingServiceSelected</ExcludeFromContext>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Context>InternationalShippingServiceOption</Context>
							<Context>ShippingServiceOptions</Context>
							<Context>ShippingServiceSelected</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Context>InternationalShippingServiceOption</Context>
							<Context>ShippingServiceOptions</Context>
							<Context>ShippingServiceSelected</Context>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<Returned>Always</Returned>
							<Context>ConvertedCurrentPrice</Context>
							<Context>CurrentPrice</Context>
						</CallInfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<Returned>Conditionally</Returned>
							<Context>MinimumToBid</Context>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>GetStoreOptions</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>VerifyAddSecondChanceItem</CallName>
							<RequiredInput>Yes</RequiredInput>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>RelistItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddTransactionConfirmationItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:attribute>
		</xs:extension>
	</xs:simpleContent>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ApiAccessRuleType.xsd #####

-->
	<xs:complexType name="ApiAccessRuleType">
		<xs:annotation>
			<xs:documentation> 
Contains the definition of a rule that governs the number of times your application 
can access the eBay API (invoke a call) on an hourly, daily, or periodic basis.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CallName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The name of the call that has an access rule.
					Can be a call name (e.g., AddItem), 
					ApplicationAggregate (returns totals for all calls), or
					PasswordAuthenticationLimiter.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CountsTowardAggregate" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Whether access to this call counts toward the application's 
					aggregate limit for all calls.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DailyHardLimit" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The number of calls per day that your application
					can make to this call before being refused. The
					day starts at midnight, 00:00:00 PST. Note that the
					time is in PST, not GMT.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DailySoftLimit" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 The number of calls per day that your application
					 can make to this call before you receive a warning.
					 The day starts at midnight, 00:00:00 PST.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DailyUsage" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 The number of times your application has used this
					 call today. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HourlyHardLimit" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 The number of calls per hour that your application
					 can make to this call before being refused. Each count
					 begins on the hour, at 12:00:00, 1:00:00, and so on.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HourlySoftLimit" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 The number of calls per hour that your application
					 can make to this call before you receive a warning.
					 Each count begins on the hour, at 12:00:00, 1:00:00, and so on.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HourlyUsage" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 Number of times your application has executed this call this hour.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Period" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The length of time before your application's perodic usage counter restarts for this call.
					If the number of calls you make exceeds the periodic hard limit before the current period ends,
					further calls will be refused until the next period starts.
					Possible values: -1 (Periodic limit not enforced, could be any negative integer),
					0 (Calendar month), 30 (Number of days, could be any positive integer).
					If the period is based on the calendar month, the usage counters restart on 
					the same day of every month, regardless of the number of days in the month.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PeriodicHardLimit" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Number of calls per period that your application may make before a call is refused, 
					if the periodic limit is enforced. The length of the period is specified in Period. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PeriodicSoftLimit" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Number of calls per period that your application may make before 
					you receive a warning, if the periodic limit is enforced. 
					The length of the period is specified in Period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PeriodicUsage" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Number of calls that your application has already made this period. 
					Returns 0 if the periodic access rule has not been configured for the application. 
					The length of the period is specified in Period. 
					The start date of the period is specified in PeriodicStartDate. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PeriodicStartDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The time (in GMT) when this access rule's period started. 
					The period starts at midnight Pacific time. For example, if the period 
					begins on June 29 in 2005 when California is on Pacific Daylight Time, 
					the GMT value returned would be 2005-06-29T07:00:00.000Z
					If the period begins on December 29 in 2005 when California is on 
					Pacific Standard Time, the GMT value returned would be 
					2005-12-29T08:00:00.000Z. Only returned when the eBay Developers Program 
					has configured the start date for the access rule. 
					The start date can vary per application and per call name (i.e., per access rule).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ModTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The date and time this access rule was last modified.
					Indicates last time that values for RuleCurrentStatus, RuleStatus, 
					URL, or EnforceURL changed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RuleCurrentStatus" type="ns:AccessRuleCurrentStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 Your application's current status for this rule,
					 including whether the rule is set, the hourly
					 limit is exceeded, the daily limit is exceeded,
					 or the periodic limit is exceeded.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RuleStatus" type="ns:AccessRuleStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The status of the access rule, including whether the
					rule is turned on or off, or whether the application is
					currently blocked from using this call. No effect if 
					RuleCurrentStatus=NotSet.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetApiAccessRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ApplicationDeliveryPreferencesType.xsd #####

-->
	<xs:complexType name="ApplicationDeliveryPreferencesType">
		<xs:annotation>
			<xs:documentation>
				(in/out) Specifies preferences describing how notifications are
				delivered to an application. Note that notifications are subject
				to Anti-Spam rules. See Anti-Spam Rules in the eBay Web Services Guide for more information about these rules.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ApplicationURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The URL where eBay delivers all notifications sent
						to the application. For delivery to a server, the URL
						begins with http:// or https:// and must be well
						formed. Use a URL that is functional at the time of the
						call. For delivery to an email address, the URL begins
						with mailto: and specifies a valid email address.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ApplicationEnable" type="ns:EnableCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) A token indicating whether notifications are
						enabled or disabled. If you disable notifications,
						the application does not receive them, but notification
						preferences are not erased.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AlertEmail" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The email address where eBay sends all application
						markup and markdown event notifications. When setting the
						email address, input must be in the format
						mailto://youremailaddress@yoursite.com (with the mailto://
						prefix). The application has to subscribe to recieve these
						events using the AlertEnable field.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>Length of valid email ids</MaxLength>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AlertEnable" type="ns:EnableCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) A token indicating whether markup and markdown alerts are enabled or disabled.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NotificationPayloadType" type="ns:NotificationPayloadTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If this field is specified, the value must be eBLSchemaSOAP.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeviceType" type="ns:DeviceTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The means of receipt of notification. In most cases, it is
						Platform (typical API calls and web interaction), so this is the
						default, if not specified. For wireless applications, use SMS.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AttributeArrayType.xsd #####

-->
	<xs:complexType name="AttributeArrayType">
		<xs:annotation>
			<xs:documentation>
		Reserved for future use.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Attribute" type="ns:AttributeType"  minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Only applicable to Half.com. Not applicable to eBay listings.
            You can revise this field for Half.com listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseItem</CallName>
							<!-- Half.com does not support RelistItem. -->
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AttributeRecommendationsType.xsd #####

-->
	<xs:complexType name="AttributeRecommendationsType">
		<xs:annotation>
			<xs:documentation> 
				Item Specifics data returned from the Suggested Attributes engine.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AttributeSetArray" type="ns:AttributeSetArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					A list of attribute sets containing recommended attributes and values. 
					Returned from GetItemRecommendations when the Suggested Attributes engine is used 
					See the eBay Web Services guide for additional details.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AttributeSetArrayType.xsd #####

-->
	<xs:complexType name="AttributeSetArrayType">
		<xs:annotation>
			<xs:documentation> 
		(in/out) Applicable for listings that include eBay's Item Specifics or Pre-filled Item Information features.
      A list of attribute sets. An attribute set contains a list of attributes
      that describe category-specific aspects or features of an item in a standardized way.
      See the Developer's Guide for more information. In item-listing requests, 
      this property is required if attributes are identified as required in the 
      characteristics set meta-data. 
      See the Developer's Guide for information about characteristics meta-data and how to 
      determine when attributes are required.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AttributeSet" type="ns:AttributeSetType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
            (in/out) Contains a list of attributes that describe category-specific aspects or 
            features of an item in a standardized way. 
            For the AddItem family of calls and GetItem, an AttributeSetArrayType can contain a maximum of 2 full attribute sets 
            (one for each category in which the item is listed) if the primary and secondary categories 
            are mapped to different characteristics sets. If they are mapped to the same characteristics set, 
            the AttributeSetArrayType can contain one full attribute set.
            An AttributeSetArrayType can also contain any number of additional site-wide attribute sets.
            In item-listing requests, this property is required if attributes 
            are identified as required in the characteristics set meta-data. 
            See the Developer's Guide for information about 
            characteristics meta-data and validation rules that are applicable when listing items.
            Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AttributeSetType.xsd #####

-->
	<xs:complexType name="AttributeSetType">
		<xs:annotation>
			<xs:documentation> 
      (in/out) A set of salient aspects or features that describe an item in a standardized way.
      Most commonly used in the Item Specifics section of a listing.
      See the Developer's Guide information on 
      working with Item Specifics and Pre-filled Item Information.
      See the Developer's Guide for information about 
      characteristics meta-data and how to determine when attributes are required.
               </xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Attribute" type="ns:AttributeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
            A salient aspect or feature of an item in a given category. 
            Attributes are known as "Item Specifics" in the eBay Web site. 
            Use attributes to describe an item in a standard way so that buyers can find it more easily.
            For example, "Publication Year" is a standard attribute for books.
            In item-listing requests, multiple attributes can be specified. 
            Some categories (e.g., Tickets) always require certain attributes to be specified. 
            Therefore, in item-listing requests you need to at least specify "editable" attributes 
            (EditType 0 and EditType 2 attributes) if they are identified as required 
            in the attribute meta-data. See the eBay Web Services guide for information 
            about attrribute meta-data, how to determine the valid attributes for a category, 
            and how to determine whether attributes are required.
            &lt;br&gt;&lt;br&gt;
            If you are revising or relisting an item, you don't need to pass in attributes 
            that were already specified in the original listing.
            To remove an optional attribute, set all its value IDs to "-100". If the item has bids 
            (or items have been sold) but there are more than 12 hours remaining until the listing ends, 
            you can add Attribute nodes but you cannot remove or modify data in previously 
            specified Attribute nodes. If the item has bids and the listing ends within 12 hours, 
            you cannot add or remove Attribute nodes or modify the contents of previously 
            specified Attribute nodes. 
            &lt;br&gt;&lt;br&gt;
            For GetCategoryListings, this returns the item condition only (and it is 
            only returned if IncludeCondition = true in the request).
            Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="attributeSetID" type="xs:int">
			<xs:annotation>
				<xs:documentation>
         Constant value that identifies the attribute set in a language-independent way.
         Unique across all eBay sites. Corresponds to a characteristics set ID. 
         Call GetCategory2CS to determine valid characteristics set IDs.
         For GetCategoryListings, you can ignore this value.
         Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>AddLiveAuctionItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>Conditionally</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetSearchResults</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>ReviseLiveAuctionItem</CallName>
						<RequiredInput>No</RequiredInput>
						</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetCategoryListings</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="attributeSetVersion" type="xs:string" use="optional">
			<xs:annotation>
				<xs:documentation>
         Version of the attribute set being specified (in requests) or that is
         currently on the site. This value changes each time changes are made to the 
         category-to-characteristic set mappings or characteristic set data.
         The current version value is not necessarily greater than the previous
         value. Therefore, when comparing versions, only compare whether the
         value has changed.&lt;br&gt;&lt;br&gt;
         In listing requests, if you do not specify this value, eBay assumes you are 
         using the current attribute set version. If you specify the version number of 
         the attribute meta-data that you have stored locally, eBay will compare it to 
         the current version on the site and return a warning if the versions do not match. 
         If an error occurs due to invalid attribute data, this warning can be useful to help you
         determine if you might be sending outdated data.
         Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>AddLiveAuctionItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>Conditionally</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetSearchResults</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>ReviseLiveAuctionItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItemRecommendations</CallName>
						<Returned>Conditionally</Returned>
						<!-- N/A to GetSearchResults output -->
					</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AttributeType.xsd #####

-->
	<xs:complexType name="AttributeType">
	<xs:annotation>
		<xs:documentation>
			A salient aspect or feature of an item. On eBay.com, this information is used in the Item Specifics
			section of a listing to describe an item
			in a standard way so that buyers can find it more easily.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="Value" type="ns:ValType" maxOccurs="unbounded" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					A value the seller selected or entered for the attribute.
					At least one value is required for each Attribute that you specify.
					Some attributes can have multiple values.
					See the eBay Web Services guide sections on
					Item Specifics (Attributes) and Pre-filled Item Information (Catalogs)
					for information about using GetAttributesCS to determine valid
					attribute values.&lt;br&gt;&lt;br&gt;

					For eBay.com listings, use AttributeSetArray.AttributeSet.Attribute.Value.
					For Half.com, use AttributeArray.Attribute.Value. That is, the parent elements
					and usage for Half.com differs from
					eBay's standard Item Specifics format (and there is no relationship to GetAttributesCS).
					For Half.com, this does not use the same Attributes logic as eBay's Item Specifics.
					For Half.com, AttributeArray.Attribute.Value is required when you use AddItem.
					see the eBay Web Services Guide for valid values.
					You can revise AttributeArray.Attribute.Value for Half.com listings.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>AddLiveAuctionItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>Conditionally</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetSearchResults</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>ReviseLiveAuctionItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetCategoryListings</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
	<xs:attribute name="attributeID" type="xs:int">
		<xs:annotation>
			<xs:documentation>
				Constant value that identifies the attribute in a language-independent way.
				Unique within the attribute set.
				See the Developer's Guide topics on Item Specifics and Pre-filled Item Information
				for information about determining valid attribute IDs.
				Not applicable to Half.com.
			</xs:documentation>
			<xs:appinfo>
				<CallInfo>
					<CallName>AddItem</CallName>
					<CallName>AddLiveAuctionItem</CallName>
					<CallName>GetItemRecommendations</CallName>
					<CallName>VerifyAddItem</CallName>
					<Context>AttributeSetArray</Context>
					<RequiredInput>Conditionally</RequiredInput>
				</CallInfo>
				<CallInfo>
					<CallName>GetSearchResults</CallName>
					<CallName>RelistItem</CallName>
					<CallName>ReviseItem</CallName>
					<CallName>ReviseLiveAuctionItem</CallName>
					<Context>AttributeSetArray</Context>
					<RequiredInput>No</RequiredInput>
				</CallInfo>
				<CallInfo>
					<CallName>GetBidderList</CallName>
					<CallName>GetCategoryListings</CallName>
					<CallName>GetItemRecommendations</CallName>
					<CallName>GetSearchResults</CallName>
					<Returned>Conditionally</Returned>
				</CallInfo>
				<CallInfo>
					<CallName>GetItem</CallName>
					<Returned>Conditionally</Returned>
					<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
				</CallInfo>
			</xs:appinfo>
		</xs:annotation>
	</xs:attribute>
	<xs:attribute name="attributeLabel" type="xs:string">
		<xs:annotation>
			<xs:documentation>
				Name of the attribute being specified. This is not part of
				eBay's standard Item Specifics format (i.e., there is no
				relationship to GetAttributesCS). For GetCategoryListings, this
				returns the value "Condition" to identify the item condition
				attribute. For GetOrders, this is always returned for Half.com
				orders. (It is not applicable to orders on the eBay.com site.)
				For Half.com, see the eBay Web Services Guide for valid input
				values. For Half.com, this field is required when you use
				AddItem. You can revise this value for Half.com listings.
			</xs:documentation>
			<xs:appinfo>
				<CallInfo>
					<CallName>AddItem</CallName>
					<CallName>GetItemRecommendations</CallName>
					<CallName>VerifyAddItem</CallName>
					<Context>AttributeArray</Context>
					<RequiredInput>Conditionally</RequiredInput>
				</CallInfo>
				<CallInfo>
					<CallName>ReviseItem</CallName>
					<Context>AttributeArray</Context>
					<RequiredInput>No</RequiredInput>
					<!-- N/A to RelistItem -->
				</CallInfo>
				<CallInfo>
					<CallName>GetCategoryListings</CallName>
					<Returned>Conditionally</Returned>
					<!-- N/A to GetItem or related calls -->
				</CallInfo>
				<CallInfo>
					<CallName>GetOrders</CallName>
					<Returned>Always</Returned>
				</CallInfo>
			</xs:appinfo>
		</xs:annotation>
	</xs:attribute>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AuthenticationEntryArrayType.xsd #####

-->
	<xs:complexType name="AuthenticationEntryArrayType">
		<xs:annotation>
			<xs:documentation>
				Container for a list of AuthenticationEntries. Can contain zero, one, or multiple
				AuthenticationEntryType objects.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AuthenticationEntry" type="ns:AuthenticationEntryType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Contains the data properties that define one authentication entry.
            Multiple AuthenticationEntry fields can be returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/AuthenticationEntryType.xsd #####

-->
	<xs:complexType name="AuthenticationEntryType">
		<xs:annotation>
			<xs:documentation>
				A set of application-level authentication preferences and related data that
				you configure to support the user authentication and authorization process.
    	</xs:documentation>
			<xs:appinfo>
				<SeeLink>
					<Title>Authentication &amp; Authorization</Title>
					<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
				</SeeLink>
			</xs:appinfo>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AcceptURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A URL that you set up in order to determine when a
            user's authentication and authorization process succeeded.
            After a user signs into eBay and authorizes your application
            to execute secure calls on their behalf, eBay redirects the
            user's browser to this URL and, if TokenReturnMethod is set
            to Redirect, appends the user's authentication token plus
            other data that you specified to identify the user.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500</MaxLength>
						<CallInfo>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrivacyPolicyURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Your privacy policy URL, which is shown to end users on the eBay sign-in page.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500</MaxLength>
						<CallInfo>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RejectURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A URL that you set up in order to determine when a
            user's authentication and authorization process did not succeed.
            After a user signs into eBay but chooses NOT to authorize your application
            to execute secure calls on their behalf, eBay redirects the
            user's browser to this URL and appends data that you specified
            to identify the user (but does not return an authentication token).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500</MaxLength>
						<CallInfo>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RuName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A unique identifier associated with application and the combination
            of URLs within this authentication entry.
            Unique across all applications that execute eBay Web Services calls.
            For convenience, you can call GetRuName to generate a unique value.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>255</MaxLength>
						<CallInfo>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TokenReturnMethod" type="ns:TokenReturnMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Specifies whether to return the token in the HTTP response stream
            sent to the accept URL, or to make it available for retrieval via FetchToken.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetReturnURL</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetReturnURL</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Authentication &amp; Authorization</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=AuthNAuth</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BalanceCodeList.xsd #####

-->
	<xs:simpleType name="BalanceCodeType">
		<xs:annotation>
			<xs:documentation>
           BalanceCodeType - Type declaration to be used by other schema. This
           code identifies the types of balances in an account, e.g., a PayPal
           account.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
                (out) Custom Code.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BasicAmountType.xsd #####

-->
	<xs:complexType name="BasicAmountType">
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="currencyID" type="ns:CurrencyCodeType" use="required"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BasicUpgradePackEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="BasicUpgradePackEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the BasicUpgradePack feature (a feature pack). If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned). Australia site (site ID 15, abbreviation AU) only.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferActionCodeList.xsd #####

-->
	<xs:simpleType name="BestOfferActionCodeType">
		<xs:annotation>
			<xs:documentation>
				Indicates the action taken by a seller for a best offer. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Accept">
				<xs:annotation>
					<xs:documentation>
						(in/out) To accept something.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Decline">
				<xs:annotation>
					<xs:documentation> 
						To decline something.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Counter">
				<xs:annotation>
					<xs:documentation> 
						To counter offer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
				<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BestOfferArrayType.xsd #####

-->
	<xs:complexType name="BestOfferArrayType">
		<xs:annotation>
			<xs:documentation> 
				A collection of Best Offers. Empty if there are no best offers.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BestOffer" type="ns:BestOfferType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
						A container of details about a best offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>RespondToBestOffer</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferAutoDeclineEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="BestOfferAutoDeclineEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the BestOfferAutoDeclineEnabled feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferCounterEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="BestOfferCounterEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the BestOfferCounterEnabled feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferDetailsType.xsd #####

-->
	<xs:complexType name="BestOfferDetailsType">
		<xs:annotation>
			<xs:documentation>
				Container for BestOffer properties associated with the item.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BestOfferCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The number of best offers made for this item, if any.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether best offer is enabled for this item.
						If a listing has no active best offers, you can change this value (true to false, and vice versa).
						If a listing does have active best offers, you cannot change the value to false.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>GetItemRecommendations</CallName>
						  <CallName>RelistItem</CallName>
						  <CallName>ReviseItem</CallName>
						  <CallName>VerifyAddItem</CallName>
						  <RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOffer" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(GetMyeBayBuying only) Indicates the latest BestOffer the user has provided for the item .
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferStatus" type="ns:BestOfferStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(GetMyeBayBuying only) Indicates the status of the latest BestOffer the user has provided for the item .
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferType" type="ns:BestOfferTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the best offer type of the latest BestOffer the user has provided for the item .
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="BestOfferEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the BestOfferEnabled feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferIDType.xsd #####

-->
	<xs:simpleType name="BestOfferIDType">
		<xs:annotation>
			<xs:documentation>
				Unique identifier for a best offer (to differentiate from
				other best offers for the same item).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BestOfferStatusCodeList.xsd #####

-->
	<xs:simpleType name="BestOfferStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				The status of the best offer.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						The best offer is awaiting seller response or will naturally expire after 48 hours.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Accepted">
				<xs:annotation>
					<xs:documentation>
						The best offer was accepted by the seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Declined">
				<xs:annotation>
					<xs:documentation>
						The best offer was rejected by the seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Expired">
				<xs:annotation>
					<xs:documentation>
						The best offer expired after 48 hours due to no action by the seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Retracted">
				<xs:annotation>
					<xs:documentation>
						The best offer was retracted by the buyer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AdminEnded">
				<xs:annotation>
					<xs:documentation>
						The best offer was ended by an administrator.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
						Retrieve active best offers only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Countered">
				<xs:annotation>
					<xs:documentation>
						Retrieve all counter best offers.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="All">
				<xs:annotation>
					<xs:documentation>
						Retrieve all best offers (including declined offers, etc.).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BestOfferType.xsd #####

-->
	<xs:complexType name="BestOfferType">
		<xs:annotation>
			<xs:documentation>
				Details about a best offer.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BestOfferID" type="ns:BestOfferIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An id to distinguish this best offer from other best offers
						made on the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpirationTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Date and time (in GMT) the offer naturally expires (if the
						seller has not accepted or declined the offer).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Buyer" type="ns:UserType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Information about the buyer who made the best offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Price" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The amount of the best offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:BestOfferStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The state of the offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Quantity" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of items for which the buyer is making an offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Text message provided by buyer when placing best offer.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500 (in bytes)</MaxLength>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Text response to buyer from seller.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500 (in bytes)</MaxLength>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferCodeType" type="ns:BestOfferTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The best offer type.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CallStatus" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The status of the call, either Success or Failure.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>RespondToBestOffer</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BestOfferTypeCodeType.xsd #####

-->
	<xs:simpleType name="BestOfferTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				The offer type of the best offer.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="BuyerBestOffer">
				<xs:annotation>
					<xs:documentation>
						The buyer has placed best offer on the item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerCounterOffer">
				<xs:annotation>
					<xs:documentation> 
						The buyer has made a counter offer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerCounterOffer">
				<xs:annotation>
					<xs:documentation>
						The seller has made a counter offer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BidActionCodeList.xsd #####

-->
	<xs:simpleType name="BidActionCodeType">
		<xs:annotation>
			<xs:documentation>
          BidActionCodeType - Type declaration to be used by other schema.
          These are the possible codes for types of bid.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unknown">
				<xs:annotation>
					<xs:documentation>
                Unknown
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Bid">
				<xs:annotation>
					<xs:documentation>
                (in/out) Bid. The offer is being or was placed on a competitive-bidding
                listing (a Chinese or Dutch auction).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotUsed">
				<xs:annotation>
					<xs:documentation>
                (out) Not used.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Retraction">
				<xs:annotation>
					<xs:documentation>
                (out) Retraction. The offer was retracted by the user who extended the
                offer. (Must be done on the eBay site, not possible through the API.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AutoRetraction">
				<xs:annotation>
					<xs:documentation>
                (out) Auto-retraction. The offer was auto-retracted. (Must be done on the
                eBay site, not possible through the API.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Cancelled">
				<xs:annotation>
					<xs:documentation>
                (out) Cancelled. The offer was cancelled. (Must be done on the eBay site,
                not possible through the API.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AutoCancel">
				<xs:annotation>
					<xs:documentation>
                (out) Auto-cancel. The offer was auto-cancelled. (Must be done on the eBay
                site, not possible through the API.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Absentee">
				<xs:annotation>
					<xs:documentation>
                (out) Absentee. The offer placed was an absentee bid. (Must be done on the
                eBay site, not possible through the API.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyItNow">
				<xs:annotation>
					<xs:documentation>
                (out) BuyItNow. The offer resulted in the successful exercise of the Buy It
                Now option for a Chinese auction.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Purchase">
				<xs:annotation>
					<xs:documentation>
                (in/out) Purchase. The offer is being or was placed on a fixed-price listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BidApprovalArrayType.xsd #####

-->
	<xs:complexType name="BidApprovalArrayType">
		<xs:annotation>
			<xs:documentation>
			Mulitple bidders can be approved with one call.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LiveAuctionBid" type="ns:BidApprovalType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					The settings the seller specifies about one user when approving or denying 
					that user's request to bid on items in the seller's Live Auctions catalog.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BidApprovalType.xsd #####

-->
	<xs:complexType name="BidApprovalType">
		<xs:annotation>
			<xs:documentation>
			Information that a Live Auction seller selects when approving or denying 
			a user who wants to bid on items in the seller's Live Auctions catalog.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						User ID for the bidder to be approved.
						Only users that have requested approval can be approved. 
						That is, the seller cannot approve a bidder that has not requested approval 
						via the web flow. When you are approving bidders, if you pass in multiple 
						BidApproval entries with duplicate UserID values,
						the last entry with that UserID is used for the request (and the earlier 
						duplicate UserID entries are ignored).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>					
				</xs:annotation>
			</xs:element>
			<xs:element name="ApprovedBiddingLimit" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount that seller is approving the bidders for. 
						This field is required if the seller has requested for the bidders 
						to enter the amount to be approved.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>					
				</xs:annotation>
			</xs:element>
			<xs:element name="DeclinedComment" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Comments entered by seller when an appoval request is declined. 
						This is required if seller is setting Status="Denied".
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>					
				</xs:annotation>
			</xs:element>			
			<xs:element name="Status" type="ns:BidderStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Sellers set the status. See BidderStatusCodeType for possible values.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>					
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
			
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BidderDetailArrayType.xsd #####

-->
	<xs:complexType name="BidderDetailArrayType">
		<xs:annotation>
			<xs:documentation> 
				A collection of Bidder Detail.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BidderDetail" type="ns:BidderDetailType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
						Details about a Live Auctions bidder.
						Returned if at least one bidder has requested approval.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BidderDetailType.xsd #####

-->
	<xs:complexType name="BidderDetailType">
		<xs:annotation>
			<xs:documentation> 
        Contains the data for a user who is interested in bidding on items in a Live Auctions catalog.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					ID of the user requesting approval.
					</xs:documentation>
					<xs:appinfo> 	
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Email" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						E-mail address of the bidder. 
						You cannot retrieve an email address for any user with whom 
						you do not have a transactional relationship, regardless of 
						site. Email is only returned for applicable calls when you 
						are retrieving your own user data OR when you and the other 
						user are in a transactional relationship and the call is 
						being executed within a certain amount of time after the 
						transaction is created.
						Returned as CDATA. When an email address can not be returned, 
						the string "Invalid Request" is returned instead.
					</xs:documentation>
					<xs:appinfo> 	
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackScore" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Aggegate feedback score for the specified user. 
					Feedback score is only return if the user has not chosen to make his 
					or her feeback private.
					</xs:documentation>
					<xs:appinfo> 	
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UniqueNegativeFeedbackCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Total count of negative feeback entries from unique users who have left 
					feedback for the user.
					</xs:documentation>
					<xs:appinfo> 	
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UniquePositiveFeedbackCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Total count of positive feeback entries from unique users who have left 
					feedback for the user.
					</xs:documentation>
					<xs:appinfo> 	
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>	
			<xs:element name="LiveAuctionBidResult" type="ns:LiveAuctionBidType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains the bidder details that match the bidder query
						passed in the request. 
						Always returned when bidder search results are found.
					</xs:documentation>
					<xs:appinfo> 	
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
			
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BidderIdType.xsd #####

-->
	<xs:simpleType name="BidderIdType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:int"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BidderNoticePreferencesType.xsd #####

-->
	<xs:complexType name="BidderNoticePreferencesType">
		<xs:annotation>
			<xs:documentation>
			  Contains a seller's preferences for receiving bidder notices.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UnsuccessfulBidderNoticeIncludeMyItems" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  If true, sends the seller a notice containing the contact information for unsuccessful
					  bidders.
				  </xs:documentation>
				  <xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BidderStatusCodeList.xsd #####

-->
	<xs:simpleType name="BidderStatusCodeType">
		<xs:annotation>
			<xs:documentation>
This code identifies the status of the Bidder's request 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Approved">
				<xs:annotation>
					<xs:documentation>
               (in/out) Bidder's request is approved.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>			
			<xs:enumeration value="Denied">
				<xs:annotation>
					<xs:documentation>
               (in/out) Bidder's request is denied.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
					(out) Bidder's request is pending.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
				
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BidderTypeCodeList.xsd #####

-->
	<xs:simpleType name="BidderTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				BidderTypeCodeType - Type declaration to be used by other schema.
				Specifies the whether to retrieve all bidders for ended or open
				listings. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AllBidder">
				<xs:annotation>
					<xs:documentation>
						(in) Retrieve all bidders for ended or open listings.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HighBidder">
				<xs:annotation>
					<xs:documentation>
						(in) Retrieve all high bidders.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BiddingDetailsType.xsd #####

-->
	<xs:complexType name="BiddingDetailsType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ConvertedMaxBid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Converted value of the value in MaxBid, in the currency indicated by SiteCurrency.
						For active items, refresh the listing's data every 24
						hours to pick up the current conversion rates. Under conditions where this value
						would be N/A on the eBay site, this element is not returned at all.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxBid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
								Indicates the maximum amount the user has agreed to pay for the item when the
								user last submitted a bid. Under conditions where this value would be
								N/A on the eBay site, this element is not returned at all.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QuantityBid" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(GetMyeBay only) Number of items from the listing the user agreed to
						purchase with a bid. For single-item listings, always 1.
						For multi-item listings, will be between 1 and the number of items offered in the auction.
						Number of items purchased so far.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QuantityWon" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(GetMyeBay only) Used mainly for Dutch auction. For an active listing,
						number of items the user stands to win if the user is a current winning bidder.
						For an ended listing, number of items the user actually won.
						In both cases, the number may be less than that returned in
						QuantityBid as the lowest winning bidder in a Dutch auction might not win
						the number of items the user has bid on.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Winning" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(GetMyeBay only) Indicates whether the user is the current
						high bidder in a currently active listing.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BulkCatalogListerStatusCodeList.xsd #####

-->
	<xs:simpleType name="BulkCatalogListerStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Preapproved">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OnWatch">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OnHold">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Suspended">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WatchWarn">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BuyerProtectionCodeList.xsd #####

-->
	<xs:simpleType name="BuyerProtectionCodeType">
		<xs:annotation>
			<xs:documentation>
           BuyerProtectionCodeType - Type declaration to be used by other
           schema. Indicates the status of the item's eligibility for the Buyer
           Protection Program.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ItemIneligible">
				<xs:annotation>
					<xs:documentation>
                (out) Item is ineligible (e.g., category not applicable).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemEligible">
				<xs:annotation>
					<xs:documentation>
                (out) Item is eligible per standard criteria.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemMarkedIneligible">
				<xs:annotation>
					<xs:documentation>
                (out) Item marked ineligible per special criteria (e.g., seller's account closed).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemMarkedEligible">
				<xs:annotation>
					<xs:documentation>
                (out) Item marked eligible per other criteria.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/BuyerRequirementsType.xsd #####

-->
	<xs:complexType name="BuyerRequirementsType">
		<xs:annotation>
			<xs:documentation>
				Container for all buyer requirements in listing calls.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ShipToRegistrationCountry" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If true, blocks bidders who are registered in countries to which
						the seller has specified he will not shipo.
						Ignored as input if the application uses version 451 or older.
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ZeroFeedbackScore" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If true, blocks bidders with a feedback score of 0 who attempt to bid on
						Buy It Now items worth 100 RMB or more.
						Ignored as input if the application uses version 451 or older.
						This requirement is only enabled for the CN site.
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumFeedbackScore" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If true, blocks bidders with this feedback score or lower.
						Ignored as input if the application uses version 451 or older.
						Valid values: -3, -2, -1.
					</xs:documentation>
					<xs:appinfo>
						<Min/>
						<Max/>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaximumUnpaidItemStrikes" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If true, blocks bidders who have received two unpaid item
						strikes in the last 30 days.
						Ignored as input if the application uses version 451 or older.
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaximumItemRequirements" type="ns:MaximumItemRequirementsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) A means of limiting unpaying, low feedback bidders.
						Ignored as input if the application uses version 451 or older.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LinkedPayPalAccount" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If true, only bidders with PayPal accounts linked to eBay may bid.
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VerifiedUserRequirements" type="ns:VerifiedUserRequirementsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) A means of limiting unverified bidders.
						Ignored as input if the application uses version 451 or older.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BuyerType.xsd #####

-->
	<xs:complexType name="BuyerType">
		<xs:annotation>
			<xs:documentation>
				Contains information about a user as a buyer.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ShippingAddress" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains the address of the buyer in the transaction, to which the seller
						would ship the item(s). See AddressType for its child elements. GetAllBidders
						is returning only Country and PostalCode currently.
						Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
					<!-- N/A: GetUser -->
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BuyingGuideDetailsType.xsd #####

-->
	<xs:complexType name="BuyingGuideDetailsType">
		<xs:annotation>
			<xs:documentation>
          Information about zero or more buying guides and the site's buying guide hub.
          Buying guides contain content about particular product areas, categories, or subjects 
          to help buyers decide which type of item to purchase based on their particular interests.  
          Multiple buying guides can be returned. See the eBay Web Services Guide for additional information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BuyingGuide" type="ns:BuyingGuideType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Information that identifies a buying guide. A buying guide contains content about particular 
            product areas, categories, or subjects to help buyers decide which type of item 
            to purchase based on their particular interests.  
            Buying guides are useful to buyers who do not have a specific product in mind. 
            For example, a digital camera buying guide could help a buyer determine what kind of 
            digital camera is right for them.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyingGuideHub" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            URL of the buying guide home page for the site being searched.
            Your application can present this URL as a link. Optionally, 
            you can use a value like "See all buying guides" as the link's display name.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BuyingGuideType.xsd #####

-->
	<xs:complexType name="BuyingGuideType">
		<xs:annotation>
			<xs:documentation>
				Information that identifies a buying guide. A buying guide provides content about particular
				product areas, categories, or subjects to help buyers decide which type of item
				to purchase based on their particular interests.
				Buying guides are useful to buyers who do not have a specific product in mind.
				For example, a digital camera buying guide could help a buyer determine what kind of
				digital camera is right for them.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
		<xs:element name="Name" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Display name of the buying guide. Typically similar to the name of the category
					or product finder associated with the buying guide.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryListings</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="URL" type="xs:anyURI" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					URL for the buying guide. Your application can
					present this as a link. Use the value of Name as the link's display name.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryListings</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CategoryID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Identifies the category (if any) that is associated
					with the buying guide. This can be a category that is higher or lower in the hierarchy
					than the category specified in the request. For a matching categories search,
					you can use this information to determine the order that the buying guides are
					returned in when multiple guides are found.
					Optionally, you can use this information to determine where to present
					the buying guide link in your application.
					Not returned for product finder searches.
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>10</MaxLength>
					<CallInfo>
						<CallName>GetCategoryListings</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ProductFinderID" type="xs:int" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Identifies the product finder (if any) that is associated with the buying guide.
					Only returned for product finder searches.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/BuyingSummaryType.xsd #####

-->
	<xs:complexType name="BuyingSummaryType">
		<xs:sequence>
			<xs:element name="BiddingCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
				     	The number of items the user has bid on.
					</xs:documentation>
				 <xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBayBuying</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WinningCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 The number of items the user has bid on and is winning, but that have not yet ended.
					</xs:documentation>
					 <xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalWinningCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
				     	The total cost of items the user is presently winning.
					</xs:documentation>
					 <xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WonCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The number of items the user has bid on and won.
					</xs:documentation>
					 <xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalWonCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 The total cost of items the user has bid on and won.
					</xs:documentation>
					 <xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WonDurationInDays" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The time period for which won items are displayed. Default is 31 days.
					</xs:documentation>
					 <xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferCount" type="xs:int" minOccurs="0">
			  	<xs:annotation>
			    		<xs:documentation>
			    		The number of items the user has made best offers on.
			    		</xs:documentation>
					 <xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
			  	</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CalculatedShippingChargeOptionCodeList.xsd #####

-->
	<xs:simpleType name="CalculatedShippingChargeOptionCodeType">
		<xs:annotation>
			<xs:documentation>
				Calculated Shipping Charge Options
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ChargeEachItem">
				<xs:annotation>
					<xs:documentation>
						Charge the actual shipping cost and my full packaging and handling
						fee for each item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ChargeEntireOrder">
				<xs:annotation>
					<xs:documentation>
						Charge the actual shipping cost and a packaging and handling fee of
						X amount for the entire order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CalculatedShippingPreferencesType.xsd #####

-->
	<xs:complexType name="CalculatedShippingPreferencesType">
		<xs:annotation>
			<xs:documentation>
				Calculated shipping preferences for the user.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CalculatedShippingAmountForEntireOrder" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The calculated shipping amount for the entire order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CalculatedShippingChargeOption" type="ns:CalculatedShippingChargeOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether to charge the actual shipping and handling cost for the entire order
						or for each item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CalculatedShippingRateOption" type="ns:CalculatedShippingRateOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether to calculate the actual rate shipping based on the combined item weight
						or the individual item weight.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InsuranceOption" type="ns:InsuranceOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Whether the seller offers shipping insurance and, if
						so, whether the insurance is optional or required. Flat and
						calculated shipping.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CalculatedShippingRateOptionCodeList.xsd #####

-->
	<xs:simpleType name="CalculatedShippingRateOptionCodeType">
		<xs:annotation>
			<xs:documentation>
				Calculated Shipping Rate Options.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="CombinedItemWeight">
				<xs:annotation>
					<xs:documentation>
						Calculate the Actual Shipping Rate from Combined Item Weight
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IndividualItemWeight">
				<xs:annotation>
					<xs:documentation>
						Calculate the Actual Shipping Rate from Individual Item Weight
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CalculatedShippingRateType.xsd #####

-->
	<xs:complexType name="CalculatedShippingRateType">
		<xs:annotation>
			<xs:documentation>
				(in/out) Details pertinent to one or more items for which
				calculated shipping has been offered by the seller, such as package
				dimension and weight and packaging/handling costs. Also returned
				with the data for an item's transaction.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="OriginatingPostalCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Postal code for the location from which the package will be shipped.
						For calculated shipping only.
						Use Item.PostalCode to specify the location of the item and where it will be
						shipped from. The value of Item.PostalCode overrides any value specified with
						OriginatingPostalCode, and will be used to calculate shipping costs.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackageDepth" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Depth of the package needed to ship the items.
						This is validated against the selected shipping service.
						Upon mismatch, a message is returned, such as, "Package
						dimensions exceeds maximum allowable limit for
						service XXXXX," where XXXXX is the name of the shipping service.
						For calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackageLength" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Length of the package needed to ship the items.
						Upon mismatch, a message is returned, such as, "Package
						dimensions exceeds maximum allowable limit for
						service XXXXX," where XXXXX is the name of the shipping service.
						For calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackageWidth" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Width of the package needed to ship the items.
						Upon mismatch, a message is returned, such as, "Package
						dimensions exceeds maximum allowable limit for
						service XXXXX," where XXXXX is the name of the shipping service.
						For calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackagingHandlingCosts" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Fees a seller might assess for the shipping of the
						item (in addition to whatever the shipping service might
						charge). For calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingIrregular" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Whether a package is irregular and therefore cannot go
						through the stamping machine at the shipping service office and
						thus requires special or fragile handling. For calculated
						shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingPackage" type="ns:ShippingPackageCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The nature of the package used to ship the item(s).
						Required for calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WeightMajor" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) An aspect of shipping weight whose value depends on
						the unit attribute. The following would represent a package
						weight of 5 lbs 2 oz: &amp;lt;WeightMajor unit="lbs"&amp;gt;5&amp;lt;/WeightMajor&amp;gt;
						&amp;lt;WeightMinor unit="oz"&amp;gt;2&amp;lt;/WeightMinor&amp;gt;
						See http://www.ups.com for UPS' maximum weight allowed.
						Above this maximum, the shipping type would become Freight.
						This is validated against the selected shipping service.
						Upon mismatch, a message is returned, such as, "Package weight
						exceeds maximum allowable limit for service XXXXX," where
						XXXXX is the name of the shipping service.
						For calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WeightMinor" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) An aspect of shipping weight whose value depends on
						the unit attribute. The following would represent a package
						weight of 5 lbs 2 oz: &amp;lt;WeightMajor unit="lbs"&amp;gt;5&amp;lt;/WeightMajor&amp;gt;
						&amp;lt;WeightMinor unit="oz"&amp;gt;2&amp;lt;/WeightMinor&amp;gt;
						For calculated shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CancelOfferArrayType.xsd #####

-->
	<xs:complexType name="CancelOfferArrayType">
		<xs:annotation>
			<xs:documentation> 
        Container for a list of offers. May contain zero, one, or multiple
        OfferType objects, each of which represents one offer extended by
        a user on a listing.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CancelOffer" type="ns:CancelOfferType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Contains the data for one offer. This includes: data for the user making the
            offer, the amount of the offer, the quantity of items being bought from the
            listing, the type of offer being made, and more.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CancelOfferType.xsd #####

-->
	<xs:complexType name="CancelOfferType">
		<xs:annotation>
			<xs:documentation> 
        Container for a list of offers. May contain zero, one, or multiple
        OfferType objects, each of which represents one offer extended by
        a user on a listing.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Offer" type="ns:OfferType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Contains the data for one offer. This includes: data for the user making the
            offer, the amount of the offer, the quantity of items being bought from the
            listing, the type of offer being made, and more.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="Explanation" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CategoryArrayType.xsd #####

-->
	<xs:complexType name="CategoryArrayType">
		<xs:annotation>
			<xs:documentation> 
				Container for a list of categories.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Category" type="ns:CategoryType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Contains the data for one category. See the schema documentation for
            CategoryType for details on its properties and their meanings.
            For GetCategories, not returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
						  <CallName>GetCategoryListings</CallName>
						  <CallName>GetPopularKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Always</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>UnmappedCategoryArray</Context>
						</CallInfo>
						<CallInfo>
						  <CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CategoryFeatureDetailLevelCodeList.xsd #####

-->
	<xs:simpleType name="CategoryFeatureDetailLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				The Detail Level argument for GetCategories allows the following settings to
				control the detail level of the result set.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ReturnAll">
				<xs:annotation>
					<xs:documentation>
					  Return all available data.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReturnFeatureDefinitions">
				<xs:annotation>
					<xs:documentation>
					  Return the category feature definitions only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CategoryFeatureType.xsd #####

-->
	<xs:complexType name="CategoryFeatureType">
		<xs:annotation>
			<xs:documentation>
				A container node that identifies a category that has one of the features specified in
				FeatureID (in GetCategoryFeaturesRequest).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CategoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the identifier of the category that has the feature.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingDuration" type="ns:ListingDurationReferenceType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					  Identifies the listing duration set that applies to the category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTermsRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether sellers are required to specify shipping tems
						for this category. Returned only if this category overrides the
						site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  Indicates whether best offers are allowed for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DutchBINEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  Indicates whether DutchBIN are allowed for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserConsentRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  Indicates whether a bidder must consent to the bid by confirming that
					  he or she read and agrees to the terms in eBay's privacy policy.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HomePageFeaturedEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  Indicates whether or not it is possible to enhance a listing by putting
						it into a rotation for display on a special area of the eBay home page.
						Support for this feature varies by site. Item or feedback restrictions may apply.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProPackEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether ProPackBundle (a feature pack) is enabled for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BasicUpgradePackEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the Basic Upgrade Pack bundle feature
						is enabled for this category. Australia site
						(site ID 15, abbreviation AU) only. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ValuePackEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether ValuePack bundle (a feature pack) is enabled
						for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProPackPlusEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the ProPackPlus bundle (a feature pack) is enabled for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AdFormatEnabled" type="ns:AdFormatEnabledCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the Ad Format feature is enabled for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DigitalDeliveryEnabled" type="ns:DigitalDeliveryEnabledCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether or not the digital delivery listing option is available
						for this category. Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferCounterEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether counter offers are allowed on best offers for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferAutoDeclineEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether auto decline for best offers are allowed for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketSpecialitySubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether LocalMarketSpecialitySubscription feature is supported for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketRegularSubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether LocalMarketRegularSubscription feature is supported for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketPremiumSubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether LocalMarketPremiumSubscription feature is supported for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketNonSubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether LocalMarketNonSubscription feature is supported for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether listings in this category are eligible for eBay Express
						(assuming other item and user eligibility requirements are also met).
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressPicturesRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether a listing requires a picture (or gallery image) in order
						to qualify for eBay Express when listed in this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressConditionRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether a listing requires the Item Condition
						to be specified (using Item Specifics in AttributeSetArray) in order
						to qualify for eBay Express when listed in this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumReservePrice" type="xs:double" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether Minimum Reserve Price is enabled for this
						category. Returned only if this category overrides the site default.
						Beginning mid- to late June, 2006, on the Germany, Austria, Belgium French, and Belgium Dutch
						sites, Minimum Reserve Price is supported for the Art and Antiques, Watches and Jewelry, and
						Motorbikes categories.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>		
			<xs:element name="SellerContactDetailsEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionConfirmationRequestEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the Transaction Confirmation Request feature is supported for this category.
						Returned only if this category overrides the site default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CategoryFinanceOfferArrayType.xsd #####

-->
	<xs:complexType name="CategoryFinanceOfferArrayType">
		<xs:annotation>
			<xs:documentation>
				A set of financing offers, each valid within one particular category.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CategoryFinanceOffer" type="ns:CategoryFinanceOfferType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A financing offer valid within a particular category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2FinanceOffer</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CategoryFinanceOfferType.xsd #####

-->
	<xs:complexType name="CategoryFinanceOfferType">
		<xs:annotation>
			<xs:documentation>
				A financing offer valid within a particular category.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FinanceOfferID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The unique ID for the financing offer. Call GetFinanceOffers using the FinanceOfferID
						to get more information about the offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2FinanceOffer</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The category within which the financing offer is valid.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetCategory2FinanceOffer</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CategoryListingsOrderCodeList.xsd #####

-->
	<xs:simpleType name="CategoryListingsOrderCodeType">
		<xs:annotation>
			<xs:documentation>
           CategoryListingsOrderCodeType - Type declaration to be used by other
           schema. This code identifies the CategoryListingsOrder codes (e.g.,
           for GetCategoryListings request) to be used to filter the returned
           data in the ways enumerated below.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NoFilter">
				<xs:annotation>
					<xs:documentation>
                (in) Applies no filter.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemsBy24Hr">
				<xs:annotation>
					<xs:documentation> 
                (in) Returns items that were listed in the past 24 hours.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemsEndToday">
				<xs:annotation>
					<xs:documentation> 
                (in) Reserved for internal use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemsEndIn5Hr">
				<xs:annotation>
					<xs:documentation> 
                (in) Reserved for internal use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByPriceAsc">
				<xs:annotation>
					<xs:documentation> 
				(in) Sort items by price (lowest first)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByPriceDesc">
				<xs:annotation>
					<xs:documentation> 
				(in) Sort items by price (highest first)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DistanceSort">
				<xs:annotation>
					<xs:documentation> 
				(in) Sort items by distance
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CategoryListingsSearchTypeCodeList.xsd #####

-->
	<xs:simpleType name="CategoryListingsSearchCodeType">
		<xs:annotation>
			<xs:documentation>
           CategoryListingsSearchCodeType - Type declaration to be used by
           other schema. Used to filter returned item listings to just those
           that are featured or super-featured.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Featured">
				<xs:annotation>
					<xs:documentation>
                (in) Return only featured item listings.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SuperFeatured">
				<xs:annotation>
					<xs:documentation>
                (in) Return only super-featured item listings.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CategoryMappingType.xsd #####

-->
	<xs:complexType name="CategoryMappingType">
	  <xs:annotation>
			<xs:documentation>
Mapping between an old category ID and an active category ID.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="oldID" type="xs:string">
			<xs:annotation>
				<xs:documentation>
         Identifier for an old category that has been combined with an active category. 
         Unique for the site. These IDs correspond to older category IDs that 
         calls like GetCategories have returned in the past. 
         In GetCategoryMappings, this is always returned when CategoryMapping is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryMappings</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="id" type="xs:string">
			<xs:annotation>
				<xs:documentation>
					Identifier for an active category. Unique for the site. 
					These IDs correspond to the current IDs in the category hierarchy 
					(returned from GetCategories and related calls). Multiple mappings can 
					specify the same active category ID, because different old IDs can be mapped 
					to the same active category. See "Mapping Categories on the Client Side" in the 
					eBay Web Services guide.
					In GetCategoryMappings, this is always returned when CategoryMapping is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryMappings</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>		
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CategoryType.xsd #####

-->
	<xs:complexType name="CategoryType">
		<xs:annotation>
			<xs:documentation>
        Container for data on one listing category.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BestOfferEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, the category supports best offers.
						If false or not present, the category does not support best offers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AutoPayEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the category supports Immediate Payment.
						If false or not present, the category does not support Immediate Payment.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="B2BVATEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, the category supports business-to-business (B2B) VAT
						listings. Applicable for the eBay Germany (DE), Austria (AT), or Switzerland
						CH) site only. If false or not present, the category does not support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CatalogEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, the category is associated with catalog content and the corresponding
						catalog is identified by the characteristics set ID. See CharacteristicsSets.
						As the Pre-filled Item Information feature uses the Item Specifics feature, the
						set of catalog-enabled categories is a subset of the categories that are mapped
						to characteristics sets. Not returned if false.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Distinct numeric ID for a category on eBay.
						For GetPopularKeywords, -1 represents the root
						category.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
							<Context>PrimaryCategory</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
							<Context>FreeAddedCategory</Context>
							<Context>SecondaryCategory</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetContextualKeywords</CallName>
							<CallName>GetPopularKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Always</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>UnmappedCategoryArray</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>PrimaryCategory</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>FreeAddedCategory</Context>
							<Context>SecondaryCategory</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>FreeAddedCategory</Context>
							<Context>SecondaryCategory</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>PrimaryCategory</Context>
							<Context>SecondaryCategory</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryLevel" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The level where the category fits in the site's category hierarchy.
						For example, if this field has a value of 2, then the category is two
						levels below the root category in the site's category hierarchy. Output only.
						For the GetSearchResults response, NumOfItems indicates the total quantity of
						matching items in a category. Matching categories at the same level
						(i.e., in sibling categories) are sorted by NumOfItems, descending order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<Context>CategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Display (text) name of the category as displayed on the eBay Web site.
						In GetItem, this is a fully qualified category name
						(e.g., Collectibles:Decorative Collectibles:Hummel, Goebel).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>30 (21 for China)</MaxLength>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetContextualKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
							<Context>PrimaryCategory</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
							<Context>FreeAddedCategory</Context>
							<Context>SecondaryCategory</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>PrimaryCategory</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>FreeAddedCategory</Context>
							<Context>SecondaryCategory</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
							<Context>CategoryArray</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryParentID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Category ID identifying a category that is an ancestor of
						the category indicated in CategoryID. For GetCategories, returns the same
						value as CategoryID if the CategoryLevel is 1.
						For GetSuggestedCategories, multiple CategoryParentID fields can be returned
						in sequence, starting with the root category and ending with the category that
						is the direct parent of the category specified in CategoryID.
						Use these parent fields and the CategoryID field to build the fully qualified
						category browse path or "breadcrumbs" (e.g., 58058:3516:3517).
						For GetPopularKeywords, -1 represents the root category.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryParentName" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Textual name of the category indicated in CategoryParentID.
						For GetSuggestedCategories, multiple CategoryParentName fields can be returned
						in sequence, starting with the root category and ending with the category that
						is the direct parent of the category specified in CategoryName.
						Use these parent fields and the CategoryName field to build the fully qualified
						category browse path or "breadcrumbs" (e.g., Computers &amp; Networking > Technology Books > Certification).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returned from GetCategory2CS calls with compatibility levels lower than 369.
						Supports listing with Pre-filled Item Information.
						Specifies the product finder ID associated with this category, if any. Only
						returns a value when ProductFinderAvailable is true. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<TagStatus>Obsolete</TagStatus>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductSearchPageAvailable" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Returned from GetCategory2CS calls. Supports listing with Pre-filled Item Information.
						If the category supports single-attribute search, this field returns a value of
						true. Otherwise this field not returned or returned as false.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderAvailable" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Returned from GetCategory2CS calls with compatibility levels lower than 369.
						Supports listing with Pre-filled Item Information.
						If the category supports a product finder-based search, this field returns a
						value of true. Otherwise this field returns null or false. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<TagStatus>Obsolete</TagStatus>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderIDs" type="ns:ExtendedProductFinderIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					(out) Returned from GetCategory2CS calls with compatibility level 369 and higher.
					Supports listing with Pre-filled Item Information.
					Specifies the buy-side and/or sell-side product finder IDs associated with this category, if any.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharacteristicsSets" type="ns:CharacteristicsSetType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Returned from GetCategory2CS calls.
						A list of one or more characteristics sets mapped to the category. Use this
						information when working with Item Specifics (Attributes) and Pre-filled Item
						Information (Catalogs) functionality. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
							<Context>SiteWideCharacteristicSets</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Expired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) If true, indicates a category that has expired and to which items may not be
						listed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IntlAutosFixedCat" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the category is a fixed-fee category. Use this
						information to identify categories are not eligible for eBay Stores Inventory
						format listings. You cannot list eBay Store Inventory format listings in
						fixed-fee categories on international sites. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LeafCategory" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the category indicated in CategoryID is a leaf category,
						in which items may be listed (if the category is not also expired or virtual).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Virtual" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates the that category indicated in CategoryID is a
						virtual category, to which items may not be listed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NumOfItems" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The total quantity of matching items in the category.
						In the GetSearchResults response, matching categories at the same level
						(i.e., sibling categories) are sorted by this value. That is, if the request
						specifies that fewer categories or subcategories should be returned,
						the ones with the most matching items are returned first.
						See the Developer's guide for more information.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<Context>CategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
							<Context>CategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerGuaranteeEligible" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether this category is eligible for Motors Seller Guarantee program.
						This tag is emitted for eligible categories only on the eBay Motors site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ORPA" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the category allows or disallows listing with a reserve price,
						depending on the prevailing site configuration indicated by ReservePriceAllowed.
						ORPA (override reserve price allowed) indicates when the category is an exception
						to the site's ReservePriceAllowed policy.&lt;br&gt;&lt;br&gt;
						If ORPA is true, the category overrides (toggles or reverses) the
						site's ReservePriceAllowed setting. In other words:&lt;br&gt;
						- If ReservePriceAllowed is true, reserve price is not allowed in this category.&lt;br&gt;
						- If ReservePriceAllowed is false, reserve price is allowed in this category.&lt;br&gt;&lt;br&gt;
						If ORPA is not present (or false), there is no override.
						That is, the category's setting is the same as the site's ReservePriceAllowed setting.&lt;br&gt;&lt;br&gt;
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ORRA" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the category allows or disallows reducing a listing's reserve price,
						depending on the prevailing site configuration indicated by ReduceReserveAllowed.
						ORRA (override reduce reserve allowed) indicates when the category is an exception
						to the site's ReduceReserveAllowed policy.&lt;br&gt;&lt;br&gt;
						If ORRA is true, the category overrides (toggles or reverses) the
						site's ReduceReserveAllowed setting. In other words:&lt;br&gt;
						- If ReduceReserveAllowed is true, reserve price reduction is not allowed in this category.&lt;br&gt;
						- If ReduceReserveAllowed is false, reserve price reduction is allowed in this category.&lt;br&gt;&lt;br&gt;
						If ORRA is not present (false), there is no override.
						That is, the category's setting is the same as the site's ReduceReserveAllowed setting.&lt;br&gt;&lt;br&gt;
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LSD" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Item.LotSize is not permitted when you list in this category.
						If true, indicates that lot sizes are disabled in the specified category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategories</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Keywords" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The list of keywords returned by GetPopularKeywords.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPopularKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharacteristicSetIDsType.xsd #####

-->
	<xs:complexType name="CharacteristicSetIDsType">
		<xs:annotation>
			<xs:documentation>
(in) A list of one or more characteristic set IDs. In GetProductSearchResults,
these IDs indicate which characteristic sets to search in. If not specified,
the search is conducted across all characteristic sets.
Only applicable when QueryKeywords is specified.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Numeric identifier for a characteristic set.
						Use GetCategory2CS to determine mappings between categories and
						characteristic sets that are catalog-enabled.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharacteristicType.xsd #####

-->
	<xs:complexType name="CharacteristicType">
		<xs:annotation>
			<xs:documentation>
        A salient aspect or feature of an item. Used to describe an item in a
        standard way so that buyers can find it more easily. An individual,
        standardized characteristic that is common to all items within the
        specified characteristics set. Applicable when working with Item
        Specifics (Attributes) and Pre-filled Item Information (Catalogs)
				functionality. See the eBay Web Services guide for more information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AttributeID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
         Constant value that identifies the characteristic in a language-independent way.
						Unique within the characteristic set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DateFormat" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Applicable when working with Pre-filled Item Information (Catalogs) functionality.
            Returned if the characteristic is a Date data type. Specifies the pattern
            to use when presenting the date to a user. Possible values:
            Day/Month/Year, Month/Year, Year Only.
            For example, the Year Only format would indicate that the date
            should be a value like 1999.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>SortCharacteristics</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplaySequence" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The suggested order in which the characteristic should be presented
						to the user in a list. Indicates the relative position of the sort
						key in the list of characteristics. The characteristic with the
						lowest display sequence is considered the default sort key in calls
						to GetProductSearchResults. Aside from that, usage of this display
						sequence information is optional. For example, in an application
						with a graphical user interface, a characteristic with a display
						sequence of 2 could be presented before one with a display sequence
						of 3 in a drop-down list. If multiple sort characteristics are
						returned for a characteristic set, compare their display sequence
						values to determine the lowest available value (usually 0) and the
						overall sequence.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplayUOM" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Applicable when working with Pre-filled Item Information (Catalogs) functionality.
					The unit of measure (e.g., Inch) to use when the characteristic is numeric indicates a measurement.
					Not returned if not applicable.
					Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>SortCharacteristics</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Label" type="ns:LabelType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Applicable when working with Pre-filled Item Information (Catalogs) functionality.
            The label to display when presenting the attribute to a user.
            Not necessarily the same as the attribute's label as defined in the
						characteristic set (i.e., the label could be overridden by the catalog).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SortOrder" type="ns:SortOrderCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Applicable when working with Pre-filled Item Information (Catalogs) functionality.
						Indicates the order in which eBay's search engine will sort the results if you
            pass this characteristic as a sort attribute in GetProductSearchResults.
						You cannot change the sort order of a characteristic when you perform a search.
						(Of course, you can change the sort order when you present results in your own application.)
						In GetProductSearchPage, if SortOrder is not returned at all, it means the results will be returned
						in the order in which they are stored on eBay (which can be useful for
						international sites that use ideographic characters).
						Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>SortCharacteristics</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ValueList" type="ns:ValType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            List of one or more valid values for the characteristic.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharacteristicsSearchCodeList.xsd #####

-->
	<xs:simpleType name="CharacteristicsSearchCodeType">
		<xs:annotation>
			<xs:documentation>
Indicates whether one attribute or multiple attributes can be used 
as the search criteria when calling GetProductSearchResults. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Single">
				<xs:annotation>
					<xs:documentation>
            (in/out) The search criteria can consist of one attribute.
            Applications should validate that only one searchable attribute 
            is selected for the query.
				      </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Multi">
				<xs:annotation>
					<xs:documentation> 
            (in/out) The search criteria can consist of multiple attributes.
            One or more searchable attributes can be selected, and users should be informed 
            that the search engine will apply "AND" logic to the query.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
            (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CharacteristicsSetType.xsd #####

-->
	<xs:complexType name="CharacteristicsSetType">
		<xs:annotation>
			<xs:documentation>
      A level in the eBay category hierarchy at which a particular group of
      items can share a common set of attributes. A set of characteristics
      that can be used to describe similar kinds of items in a standardized way.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The well-known name of the characteristic set (e.g., "Tickets" or "Books").
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
							<Context>SiteWideCharacteristicSets</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSetID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
         Numeric value that identifies the characteristic set in a language-independent way.
         Identifies the characteristic set that is mapped to a catalog-enabled category 
         associated with the product. Unique across all eBay sites.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
							<Context>SiteWideCharacteristicSets</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductSellingPages</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSetVersion" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Version of the characteristics set. Not to be confused with AttributeSystemVersion,
            which can be used to retrieve changes to attribute meta-data.
            In item-listing requests, if you specify the version of the attribute set
            that you have stored locally, eBay will compare it to the current version on
            the site and return a warning if the versions do not match.
            If an error occurs due to invalid attribute data, this warning can be useful
            to help determine if you might be sending outdated data.
            The current value of version is not necessarily "greater than" the
            previous value.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
							<Context>SiteWideCharacteristicSets</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Characteristics" type="ns:CharacteristicType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            A salient aspect or feature of an item. Used to describe an item
            in a standard way so that buyers can find it more easily.
            An individual, standardized characteristic that is common to all
            items within the specified characteristic set.
            In the context of GetProductSearchPage, each characteristic identifies a
            single searchable attribute. A searchable attribute is a product aspect or feature
            that can be used as a criterion in a search for catalog content.
            For example, "Title" might be a criterion for searching the book catalog
            for Pre-filled Item Information related to books.
            See the eBay Web Services guide for more information.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharityAffiliationType.xsd #####

-->
	<xs:complexType name="CharityAffiliationType">
		<xs:annotation>
			<xs:documentation>
				 Defines the affiliation status for a nonprofit charity organization registered with the dedicated eBay Giving Works provider.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="id" type="xs:string"/>
		<xs:attribute name="type" type="ns:CharityAffiliationTypeCodeType"/>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharityAffiliationTypeCodeList.xsd #####

-->
	<xs:simpleType name="CharityAffiliationTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			    CharityAffiliationTypeCodeType - Type declaration to be used by other schema.
			    Indicates the affiliation status for nonprofit charity organizations registered with the dedicated eBay Giving Works provider.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Community">
				<xs:annotation>
					<xs:documentation>
					  (out)	The specified nonprofit charity organization has a community affiliation.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Direct">
				<xs:annotation>
					<xs:documentation>
					  (out) The specified nonprofit charity organization has direct affiliation.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Remove">
				<xs:annotation>
					<xs:documentation>
					  (out)	The specified nonprofit charity organization is no longer affiliated.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						 (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CharityAffiliationsType.xsd #####

-->
	<xs:complexType name="CharityAffiliationsType">
		<xs:annotation>
			<xs:documentation>
				Lists the nonprofit charity organization affiliations for a specified user.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CharityID" type="ns:CharityIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Indicates the affiliation status for nonprofit charity organizations registered with the dedicated eBay Giving Works provider.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharityIDType.xsd #####

-->
	<xs:complexType name="CharityIDType">
		<xs:annotation>
			<xs:documentation>
				Defines the affiliation status for a nonprofit charity organization registered with the
				dedicated eBay Giving Works provider.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:string">
				<xs:attribute name="type" type="ns:CharityAffiliationTypeCodeType" use="required"/>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharityInfoType.xsd #####

-->
	<xs:complexType name="CharityInfoType">
		<xs:annotation>
			<xs:documentation>
				Contains information about a nonprofit charity organization.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A name assigned to a specified nonprofit organization.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>GetCharities</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Mission" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The stated mission of the nonprofit charity organization. This
						mission is displayed in the Giving Works item listing.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>GetCharities</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LogoURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A URL with the location of the nonprofit charity organization's logo image.
						Logo must be JPG  or GIF format, with a size maximum of 50 KB. This image is
						displayed in the Giving Works item listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCharities</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:CharityStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The status of the nonprofit charity organization.
					</xs:documentation>
					<!-- N/A: GetCharities -->
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchableString" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Keyword string to be used for search purposes.
					</xs:documentation>
					<!-- N/A: GetCharities -->
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityRegion" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Region that the nonprofit charity organization is associated with.
						A specific nonprofit charity organization may be associated with only one
						region. Meaning of input values differs depending on the site. See GetCharities
						in the API Developer's Guide for the meaning of each input/output value. CharityRegion
						input value must be valid for that SiteID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCharities</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityDomain" type="xs:int" minOccurs="0" maxOccurs="3">
				<xs:annotation>
					<xs:documentation>
						(out) Domain (mission area) that a nonprofit charity organization belongs to.
						Nonprofit charity organizations may belong to multiple mission areas. Meaning
						of input values differs depending on the site. See GetCharities in the
						API Developer's Guide for the meaning of each input/output value. CharityDomain
						input value must be valid for that SiteID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCharities</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A unique identification number assigned by eBay to registered
						nonprofit charity organizations. This number is returned in
						GetCharitiesResponse as an id attribute in the parent Charity node.
					</xs:documentation>
					<!-- N/A: GetCharities -->
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="id" type="xs:string">
			<xs:annotation>
				<xs:documentation>
					(out) A unique identification number assigned by eBay to registered
					nonprofit charity organizations.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCharities</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharitySellerStatusCodeList.xsd #####

-->
	<xs:simpleType name="CharitySellerStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			    CharitySellerStatusCodeType - Type declaration to be used by other schema.
			    Indicates the status of the seller's charity seller account.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Suspended">
				<xs:annotation>
					<xs:documentation>
					  (in/out) The seller's charity seller account is suspended.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Registered">
				<xs:annotation>
					<xs:documentation>
					  (in/out) The seller is a registered charity seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Closed">
				<xs:annotation>
					<xs:documentation>
					  (in/out) The seller is no longer a registered charity seller. The account with the eBay Giving Works provider is closed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardExpired">
				<xs:annotation>
					<xs:documentation>
					  (in/out)	The credit card associated with a seller's charity seller account has expired.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TokenExpired">
				<xs:annotation>
					<xs:documentation>
					  (in/out)	The token associated with a seller's charity seller account has expired.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardAboutToExpire">
				<xs:annotation>
					<xs:documentation>
					  (in/out)	The credit card associated with a seller's charity seller account will expire in 15 (or fewer) days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RegisteredNoCreditCard">
				<xs:annotation>
					<xs:documentation>
					  (in/out)	The seller is a registered charity seller, but has no credit card associated with the charity seller account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotRegisteredLostDirectSellerStatus">
				<xs:annotation>
					<xs:documentation>
					  (in/out)	The seller is no longer a registered charity seller and has lost direct seller status.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebitRejected">
				<xs:annotation>
					<xs:documentation>
					  (in)	The seller's direct debit card was rejected.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CharitySellerType.xsd #####

-->
	<xs:complexType name="CharitySellerType">
		<xs:annotation>
			<xs:documentation>
				Contains information about one seller with a eBay Giving Works provider 
				charity seller account.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CharitySellerStatus" type="ns:CharitySellerStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the status of the seller's charity seller account.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityAffiliation" type="ns:CharityAffiliationType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						 Indicates the affiliation status for nonprofit charity organizations registered with the dedicated eBay Giving Works provider.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CharityStatusCodeList.xsd #####

-->
	<xs:simpleType name="CharityStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			    CharityStatusCodeType - Type declaration to be used by other schema.
			    Indicates the nonprofit status of the nonprofit charity organization registered with the dedicated eBay Giving Works provider.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Valid">
				<xs:annotation>
					<xs:documentation>
					  (out)	The specified nonprofit charity organization is a valid nonprofit charity organization according to the requirements of the dedicated eBay Giving Works provider.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NoLongerValid">
				<xs:annotation>
					<xs:documentation>
					  (out)	The specified nonprofit charity organization is no longer a valid nonprofit charity organization according to the requirements of the dedicated eBay Giving Works provider.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CharityType.xsd #####

-->
	<xs:complexType name="CharityType">
		<xs:annotation>
			<xs:documentation>
				Identifies a Giving Works listing and benefiting nonprofit charity organization.
				Currently supported through the US and eBay Motors sites only. The Ad Format and
				Mature Audiences categories are not supported.
				Not applicable for US eBay Motors, international, Real Estate, and Tickets.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CharityName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The name of the benefiting nonprofit charity organization selected by the
						charity seller.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityNumber" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A unique identification number assigned to a nonprofit charity organization by the dedicated provider of
						eBay Giving Works. Being superseded by CharityID. Max 10 digits.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<!-- N/A to ReviseItem -->
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DonationPercent" type="xs:float" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					(in/out) The percentage of the purchase price that the seller donates to the selected nonprofit organization. This percentage is displayed in the Giving Works item listing. Possible values: 1.0 to 100.0. Minimum donation percentages may be required for Giving Works listings, see http://pages.ebay.com/help/sell/selling-nonprofit.html for details. DonationPercent is required input when listing Giving Works items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) A unique identification number assigned by eBay to
						registered nonprofit charity organizations. Required input when listing Giving Works items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<!-- N/A to ReviseItem -->
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Mission" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The stated mission of the nonprofit charity organization.
						This mission is displayed in the Giving Works item listing.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>512</MaxLength>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LogoURL" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The URL of the nonprofit charity organization. This URL is
						displayed in the Giving Works item listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:CharityStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The status of the nonprofit charity organization.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityListing" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) If true, indicates that the seller has chosen to use eBay
						Giving Works to donate a percentage of the item purchase price
						to a selected nonprofit organization.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CheckoutMethodCodeList.xsd #####

-->
	<xs:simpleType name="CheckoutMethodCodeType">
		<xs:annotation>
			<xs:documentation>
				The checkout method used by the buyer at external site.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
						Other Checkout Method was used.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ThirdPartyCheckout">
				<xs:annotation>
					<xs:documentation>
						Checkout is handled by a third party.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CheckoutStatusCodeList.xsd #####

-->
	<xs:simpleType name="CheckoutStatusCodeType">
		<xs:annotation>
			<xs:documentation>
           CheckoutStatusCodeType - Type declaration to be used by other schema.
           Indicates the current state of the checkout process for a transaction.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="CheckoutComplete">
				<xs:annotation>
					<xs:documentation>
                (in/out) Checkout complete. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CheckoutIncomplete">
				<xs:annotation>
					<xs:documentation>
                (in/out) Checkout incomplete--no details specified.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerRequestsTotal">
				<xs:annotation>
					<xs:documentation>
                (out) Buyer requests total from seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerResponded">
				<xs:annotation>
					<xs:documentation>
                (out) Seller responded to buyer's request.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CheckoutStatusType.xsd #####

-->
	<xs:complexType name="CheckoutStatusType">
		<xs:sequence>
			<xs:element name="eBayPaymentStatus" type="ns:PaymentStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the success or failure of a buyer's online payment.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastModifiedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The time the status was last modified.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentMethod" type="ns:BuyerPaymentMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The payment method the buyer uses to purchase the
						item.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:CompleteStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The status of the order.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CombinedPaymentOptionCodeList.xsd #####

-->
	<xs:simpleType name="CombinedPaymentOptionCodeType">
	<xs:annotation>
		<xs:documentation>
			Combined Purchase Options
		</xs:documentation>
	</xs:annotation>
	<xs:restriction base="xs:token">
		<xs:enumeration value="NoCombinedPayment">
			<xs:annotation>
				<xs:documentation>
					No Combined Purchase
				</xs:documentation>
			</xs:annotation>
		</xs:enumeration>
		<xs:enumeration value="DiscountSpecified">
			<xs:annotation>
				<xs:documentation>
					Yes Specify Discount Now
				</xs:documentation>
			</xs:annotation>
		</xs:enumeration>
		<xs:enumeration value="SpecifyDiscountLater">
			<xs:annotation>
				<xs:documentation>
					Yes Specify Discount Later
				</xs:documentation>
			</xs:annotation>
		</xs:enumeration>
		<xs:enumeration value="CustomCode">
			<xs:annotation>
				<xs:documentation>
					Reserved for internal or future use
				</xs:documentation>
			</xs:annotation>
		</xs:enumeration>
	</xs:restriction>
</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CombinedPaymentPeriodCodeList.xsd #####

-->
	<xs:simpleType name="CombinedPaymentPeriodCodeType">
		<xs:annotation>
			<xs:documentation>
				Combined Purchase Days
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Days_3">
				<xs:annotation>
					<xs:documentation>
						(in/out) 3 Days
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_5">
				<xs:annotation>
					<xs:documentation>
						(in/out) 5 Days
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_7">
				<xs:annotation>
					<xs:documentation>
						(in/out) 7 Days
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_14">
				<xs:annotation>
					<xs:documentation>
						(in/out) 14 Days
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_30">
				<xs:annotation>
					<xs:documentation>
						(in/out) 30 Days
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CombinedPaymentPreferencesType.xsd #####

-->
	<xs:complexType name="CombinedPaymentPreferencesType">
		<xs:annotation>
			<xs:documentation>
			Defines a seller's preferences for allowing buyers to combine more than one
			purchase into one payment.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CalculatedShippingPreferences" type="ns:CalculatedShippingPreferencesType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains a seller's preferences for having shipping costs calculated
						by eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CombinedPaymentOption" type="ns:CombinedPaymentOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether or not a seller wants to allow buyers 
						to combine purchases in order to receive a discount.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CombinedPaymentPeriod" type="ns:CombinedPaymentPeriodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the period in which the user will allow buyers to combine purchases in
						order to receive a discount.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FlatShippingPreferences" type="ns:FlatShippingPreferencesType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies a seller's preferences for flat-rate shipping.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CommentTypeCodeList.xsd #####

-->
	<xs:simpleType name="CommentTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				CommentTypeCodeType - Type declaration to be used by other schema.
				These are the possible codes to specify the types of feedback/comment.
				Additional information about feedback is available in the online Help of the eBay site.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Positive">
				<xs:annotation>
					<xs:documentation>
								(out) Positive feedback. Increases total feedback score.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Neutral">
				<xs:annotation>
					<xs:documentation>
								(out) Neutral feedback. No effect on total feedback score.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Negative">
				<xs:annotation>
					<xs:documentation>
								(out) Negative feedback. Decreases total feedback score.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Withdrawn">
				<xs:annotation>
					<xs:documentation>
								(out) Withdrawn feedback. Removes the effect of the original 
								feedback on total feedback score. Comments from withdrawn feedback 
								are still visible.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IndependentlyWithdrawn">
				<xs:annotation>
					<xs:documentation>
								(out) Applies to the eBay Motors site only. Feedback is withdrawn based on 
								the decision of a third party.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
								(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CompleteStatusCodeList.xsd #####

-->
	<xs:simpleType name="CompleteStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				Indicates whether the transaction process is complete, incomplete, or pending.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Incomplete">
				<xs:annotation>
					<xs:documentation>
						(in/out) Transaction is incomplete.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Complete">
				<xs:annotation>
					<xs:documentation>
						(in/out) Transaction is complete.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						(in/out) Transaction is pending.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ConditionSelectionCodeList.xsd #####

-->
	<xs:simpleType name="ConditionSelectionCodeType">
		<xs:annotation>
			<xs:documentation>
Filter that retrieves only items with the specified item conditon.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="All">
				<xs:annotation>
					<xs:documentation>
						(in) Retrieve all items that match the query, regardless of condition.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="New">
				<xs:annotation>
					<xs:documentation>
						(in) Only retrieve items that are listed as new (or the equivalent).
						That is, do not retrieve used or refurbished items (or the equivalent).
						New is the default setting. (Items that waive the Item Condition requirement
						are also returned with this setting. If necessary, you can use GetCategoryFeatures to determine 
						which categories waive the Item Condition requirement.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ContextSearchAssetType.xsd #####

-->
	<xs:complexType name="ContextSearchAssetType">
		<xs:annotation>
			<xs:documentation>
				Score and rank for a keyword identified for a web page.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Keyword" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The keyword.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>64</MaxLength>
						<CallInfo>
							<CallName>GetContextualKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Category" type="ns:CategoryType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The eBay category in which the keyword is used.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetContextualKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Score" type="xs:float" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The relevance of this keyword and category to the web page.
					</xs:documentation>
					<xs:appinfo>
						<Min>0</Min>
						<Max>1</Max>
						<CallInfo>
							<CallName>GetContextualKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Ranking" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The ranking of this keyword and category relative to
						other keywords and categories (when scores are sorted).
					</xs:documentation>
					<xs:appinfo>
						<Min>1</Min>
						<Max>2147483647</Max>
						<CallInfo>
							<CallName>GetContextualKeywords</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CountryCodeList.xsd #####

-->
	<xs:simpleType name="CountryCodeType">
		<xs:annotation>
			<xs:documentation>
CountryCodeType - Type declaration to be used by other schema.
This code list module defines the enumerated types of standard
2-letter ISO 3166 country codes. This code list also contains
some additional country codes not defined in the ISO 3166
country code set, which appear at the end of this code list and
are noted as non-ISO. Country codes may be used as input and as
output. For more information on ISO 3166 country codes, see the ISO site:
http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AF"/>
			<xs:enumeration value="AL"/>
			<xs:enumeration value="DZ"/>
			<xs:enumeration value="AS"/>
			<xs:enumeration value="AD"/>
			<xs:enumeration value="AO"/>
			<xs:enumeration value="AI"/>
			<xs:enumeration value="AQ"/>
			<xs:enumeration value="AG"/>
			<xs:enumeration value="AR"/>
			<xs:enumeration value="AM"/>
			<xs:enumeration value="AW"/>
			<xs:enumeration value="AU"/>
			<xs:enumeration value="AT"/>
			<xs:enumeration value="AZ"/>
			<xs:enumeration value="BS"/>
			<xs:enumeration value="BH"/>
			<xs:enumeration value="BD"/>
			<xs:enumeration value="BB"/>
			<xs:enumeration value="BY"/>
			<xs:enumeration value="BE"/>
			<xs:enumeration value="BZ"/>
			<xs:enumeration value="BJ"/>
			<xs:enumeration value="BM"/>
			<xs:enumeration value="BT"/>
			<xs:enumeration value="BO"/>
			<xs:enumeration value="BA"/>
			<xs:enumeration value="BW"/>
			<xs:enumeration value="BV"/>
			<xs:enumeration value="BR"/>
			<xs:enumeration value="IO"/>
			<xs:enumeration value="BN"/>
			<xs:enumeration value="BG"/>
			<xs:enumeration value="BF"/>
			<xs:enumeration value="BI"/>
			<xs:enumeration value="KH"/>
			<xs:enumeration value="CM"/>
			<xs:enumeration value="CA"/>
			<xs:enumeration value="CV"/>
			<xs:enumeration value="KY"/>
			<xs:enumeration value="CF"/>
			<xs:enumeration value="TD"/>
			<xs:enumeration value="CL"/>
			<xs:enumeration value="CN"/>
			<xs:enumeration value="CX"/>
			<xs:enumeration value="CC"/>
			<xs:enumeration value="CO"/>
			<xs:enumeration value="KM"/>
			<xs:enumeration value="CG"/>
			<xs:enumeration value="CD"/>
			<xs:enumeration value="CK"/>
			<xs:enumeration value="CR"/>
			<xs:enumeration value="CI"/>
			<xs:enumeration value="HR"/>
			<xs:enumeration value="CU"/>
			<xs:enumeration value="CY"/>
			<xs:enumeration value="CZ"/>
			<xs:enumeration value="DK"/>
			<xs:enumeration value="DJ"/>
			<xs:enumeration value="DM"/>
			<xs:enumeration value="DO"/>
			<xs:enumeration value="TP"/>
			<xs:enumeration value="EC"/>
			<xs:enumeration value="EG"/>
			<xs:enumeration value="SV"/>
			<xs:enumeration value="GQ"/>
			<xs:enumeration value="ER"/>
			<xs:enumeration value="EE"/>
			<xs:enumeration value="ET"/>
			<xs:enumeration value="FK"/>
			<xs:enumeration value="FO"/>
			<xs:enumeration value="FJ"/>
			<xs:enumeration value="FI"/>
			<xs:enumeration value="FR"/>
			<xs:enumeration value="GF"/>
			<xs:enumeration value="PF"/>
			<xs:enumeration value="TF"/>
			<xs:enumeration value="GA"/>
			<xs:enumeration value="GM"/>
			<xs:enumeration value="GE"/>
			<xs:enumeration value="DE"/>
			<xs:enumeration value="GH"/>
			<xs:enumeration value="GI"/>
			<xs:enumeration value="GR"/>
			<xs:enumeration value="GL"/>
			<xs:enumeration value="GD"/>
			<xs:enumeration value="GP"/>
			<xs:enumeration value="GU"/>
			<xs:enumeration value="GT"/>
			<xs:enumeration value="GN"/>
			<xs:enumeration value="GW"/>
			<xs:enumeration value="GY"/>
			<xs:enumeration value="HT"/>
			<xs:enumeration value="HM"/>
			<xs:enumeration value="VA"/>
			<xs:enumeration value="HN"/>
			<xs:enumeration value="HK"/>
			<xs:enumeration value="HU"/>
			<xs:enumeration value="IS"/>
			<xs:enumeration value="IN"/>
			<xs:enumeration value="ID"/>
			<xs:enumeration value="IR"/>
			<xs:enumeration value="IQ"/>
			<xs:enumeration value="IE"/>
			<xs:enumeration value="IL"/>
			<xs:enumeration value="IT"/>
			<xs:enumeration value="JM"/>
			<xs:enumeration value="JP"/>
			<xs:enumeration value="JO"/>
			<xs:enumeration value="KZ"/>
			<xs:enumeration value="KE"/>
			<xs:enumeration value="KI"/>
			<xs:enumeration value="KP"/>
			<xs:enumeration value="KR"/>
			<xs:enumeration value="KW"/>
			<xs:enumeration value="KG"/>
			<xs:enumeration value="LA"/>
			<xs:enumeration value="LV"/>
			<xs:enumeration value="LB"/>
			<xs:enumeration value="LS"/>
			<xs:enumeration value="LR"/>
			<xs:enumeration value="LY"/>
			<xs:enumeration value="LI"/>
			<xs:enumeration value="LT"/>
			<xs:enumeration value="LU"/>
			<xs:enumeration value="MO"/>
			<xs:enumeration value="MK"/>
			<xs:enumeration value="MG"/>
			<xs:enumeration value="MW"/>
			<xs:enumeration value="MY"/>
			<xs:enumeration value="MV"/>
			<xs:enumeration value="ML"/>
			<xs:enumeration value="MT"/>
			<xs:enumeration value="MH"/>
			<xs:enumeration value="MQ"/>
			<xs:enumeration value="MR"/>
			<xs:enumeration value="MU"/>
			<xs:enumeration value="YT"/>
			<xs:enumeration value="MX"/>
			<xs:enumeration value="FM"/>
			<xs:enumeration value="MD"/>
			<xs:enumeration value="MC"/>
			<xs:enumeration value="MN"/>
			<xs:enumeration value="MS"/>
			<xs:enumeration value="MA"/>
			<xs:enumeration value="MZ"/>
			<xs:enumeration value="MM"/>
			<xs:enumeration value="NA"/>
			<xs:enumeration value="NR"/>
			<xs:enumeration value="NP"/>
			<xs:enumeration value="NL"/>
			<xs:enumeration value="AN"/>
			<xs:enumeration value="NC"/>
			<xs:enumeration value="NZ"/>
			<xs:enumeration value="NI"/>
			<xs:enumeration value="NE"/>
			<xs:enumeration value="NG"/>
			<xs:enumeration value="NU"/>
			<xs:enumeration value="NF"/>
			<xs:enumeration value="MP"/>
			<xs:enumeration value="NO"/>
			<xs:enumeration value="OM"/>
			<xs:enumeration value="PK"/>
			<xs:enumeration value="PW"/>
			<xs:enumeration value="PS"/>
			<xs:enumeration value="PA"/>
			<xs:enumeration value="PG"/>
			<xs:enumeration value="PY"/>
			<xs:enumeration value="PE"/>
			<xs:enumeration value="PH"/>
			<xs:enumeration value="PN"/>
			<xs:enumeration value="PL"/>
			<xs:enumeration value="PT"/>
			<xs:enumeration value="PR"/>
			<xs:enumeration value="QA"/>
			<xs:enumeration value="RE"/>
			<xs:enumeration value="RO"/>
			<xs:enumeration value="RU"/>
			<xs:enumeration value="RW"/>
			<xs:enumeration value="SH"/>
			<xs:enumeration value="KN"/>
			<xs:enumeration value="LC"/>
			<xs:enumeration value="PM"/>
			<xs:enumeration value="VC"/>
			<xs:enumeration value="WS"/>
			<xs:enumeration value="SM"/>
			<xs:enumeration value="ST"/>
			<xs:enumeration value="SA"/>
			<xs:enumeration value="SN"/>
			<xs:enumeration value="SC"/>
			<xs:enumeration value="SL"/>
			<xs:enumeration value="SG"/>
			<xs:enumeration value="SK"/>
			<xs:enumeration value="SI"/>
			<xs:enumeration value="SB"/>
			<xs:enumeration value="SO"/>
			<xs:enumeration value="ZA"/>
			<xs:enumeration value="GS"/>
			<xs:enumeration value="ES"/>
			<xs:enumeration value="LK"/>
			<xs:enumeration value="SD"/>
			<xs:enumeration value="SR"/>
			<xs:enumeration value="SJ"/>
			<xs:enumeration value="SZ"/>
			<xs:enumeration value="SE"/>
			<xs:enumeration value="CH"/>
			<xs:enumeration value="SY"/>
			<xs:enumeration value="TW"/>
			<xs:enumeration value="TJ"/>
			<xs:enumeration value="TZ"/>
			<xs:enumeration value="TH"/>
			<xs:enumeration value="TG"/>
			<xs:enumeration value="TK"/>
			<xs:enumeration value="TO"/>
			<xs:enumeration value="TT"/>
			<xs:enumeration value="TN"/>
			<xs:enumeration value="TR"/>
			<xs:enumeration value="TM"/>
			<xs:enumeration value="TC"/>
			<xs:enumeration value="TV"/>
			<xs:enumeration value="UG"/>
			<xs:enumeration value="UA"/>
			<xs:enumeration value="AE"/>
			<xs:enumeration value="GB"/>
			<xs:enumeration value="US"/>
			<xs:enumeration value="UM"/>
			<xs:enumeration value="UY"/>
			<xs:enumeration value="UZ"/>
			<xs:enumeration value="VU"/>
			<xs:enumeration value="VE"/>
			<xs:enumeration value="VN"/>
			<xs:enumeration value="VG"/>
			<xs:enumeration value="VI"/>
			<xs:enumeration value="WF"/>
			<xs:enumeration value="EH"/>
			<xs:enumeration value="YE"/>
			<xs:enumeration value="YU"/>
			<xs:enumeration value="ZM"/>
			<xs:enumeration value="ZW"/>
			<xs:enumeration value="AA">
				<xs:annotation>
					<xs:documentation>
		                NOTE: APO/FPO was defined in eBay list previously 
		                but they are not defined in ISO 3166. This country 
		                will remain on eBay country code list for backward 
		                compatibility.
		             </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QM">
				<xs:annotation>
					<xs:documentation>
		                NOTE: Guernsey was defined in eBay list previously 
		                but they are not defined in ISO 3166. This country 
		                will remain on eBay country list for backward 
		                compatibility.
		             </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QN">
				<xs:annotation>
					<xs:documentation>
		                 NOTE: Jan Mayen was defined in eBay list previously 
		                 but they are not defined in ISO 3166. This country 
		                 will remain on eBay country list for backward 
		                 compatibility.
		             </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QO">
				<xs:annotation>
					<xs:documentation>
		                 NOTE: Jersey was defined in eBay list previously 
		                 but they are not defined in ISO 3166. This country 
		                 will remain on eBay country list for backward 
		                 compatibility.
		             </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QP">
				<xs:annotation>
					<xs:documentation>
		                 NOTE: Tahiti was defined in eBay list previously 
		                 but they are not defined in ISO 3166. This country 
		                 will remain on eBay country list for backward 
		                 compatibility.
		             </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CountryDetailsType.xsd #####

-->
	<xs:complexType name="CountryDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details about a specific country.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Country" type="ns:CountryCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Two-letter country abbreviation.&lt;br&gt;&lt;br&gt;
						Related fields:&lt;br&gt;
						Item.Country in AddItem&lt;br&gt;
						SearchLocationFilter.CountryCode in GetSearchResults
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Full country name for display purposes. May be similar to (but not necessarily identical to)
						CountryName in addresses (e.g., User.RegistrationAddress.CountryName in GetUser).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CrossPromotionPreferencesType.xsd #####

-->
	<xs:complexType name="CrossPromotionPreferencesType">
		<xs:annotation>
			<xs:documentation>
			  Contains preferences describing how items similar to the one the user is
			  presently viewing are promoted.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CrossPromotionEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only)
						Specifies whether cross-promotions are enabled for the seller's listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CrossSellItemFormatSortFilter" type="ns:ItemFormatSortFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only) Specifies which items should be shown
						in cross-sell promotions (such as Buy It Now or Store Inventory items) and 
						in which sequence.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CrossSellGallerySortFilter" type="ns:GallerySortFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only) Specifies whether to display only items with
						gallery images and whether they should precede other items in cross-sell
						promotions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CrossSellItemSortFilter" type="ns:ItemSortFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only) Specifies how to sort items displayed in 
						a cross-sell promotion.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UpSellItemFormatSortFilter" type="ns:ItemFormatSortFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only) Specifies which items (such as Buy It Now or
						Store Inventory items) should be shown in upsell promotions and in which
						sequence.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UpSellGallerySortFilter" type="ns:GallerySortFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only) Specifies whether to display only items with
						gallery images in upsell promotions and whether they should precede other items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UpSellItemSortFilter" type="ns:ItemSortFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay store owners only) Specifies how to sort items used in an upsell promotion.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CrossPromotionsType.xsd #####

-->
	<xs:complexType name="CrossPromotionsType">
		<xs:annotation>
			<xs:documentation>
				(out) Contains one or more items cross-promoted with
				the display or purchase of a referring item.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Unique item ID for the referring item.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrimaryScheme" type="ns:PromotionSchemeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The primary cross-promotion rule scheme that
						was applied to return the cross-promoted item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotionMethod" type="ns:PromotionMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The type of promotion, CrossSell or UpSell.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The eBay user ID of the seller offering the
						cross-promoted item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingDiscount" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
						(out) Whether a shipping discount is offered by the seller
						when the cross-promoted item is purchased.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerKey" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The key of the seller who is promoting the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StoreName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The store name of the seller offering the cross-promoted
					item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotedItem" type="ns:PromotedItemType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Contains one cross-promoted item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/CurrencyCodeList.xsd #####

-->
	<xs:simpleType name="CurrencyCodeType">
		<xs:annotation>
			<xs:documentation>
				This code list module defines the enumerated types of standard
				3-letter ISO 4217 currency codes. Currency codes can be used
				as input or output (in/out); however, only certain currency
				codes are currently valid for use on eBay. The valid codes are
				documented below with the notation "(in/out)". Other codes in
				this list are for future use.
				A reference: http://www.xe.com/iso4217.htm
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AFA"/>
			<xs:enumeration value="ALL"/>
			<xs:enumeration value="DZD"/>
			<xs:enumeration value="ADP"/>
			<xs:enumeration value="AOA"/>
			<xs:enumeration value="ARS"/>
			<xs:enumeration value="AMD"/>
			<xs:enumeration value="AWG"/>
			<xs:enumeration value="AZM"/>
			<xs:enumeration value="BSD"/>
			<xs:enumeration value="BHD"/>
			<xs:enumeration value="BDT"/>
			<xs:enumeration value="BBD"/>
			<xs:enumeration value="BYR"/>
			<xs:enumeration value="BZD"/>
			<xs:enumeration value="BMD"/>
			<xs:enumeration value="BTN"/>
			<xs:enumeration value="INR">
				<xs:annotation>
					<xs:documentation>
					(in/out) Indian Rupee. 
					For eBay, you can only specify this currency for listings you submit to the
					India site (site ID 203).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BOV"/>
			<xs:enumeration value="BOB"/>
			<xs:enumeration value="BAM"/>
			<xs:enumeration value="BWP"/>
			<xs:enumeration value="BRL"/>
			<xs:enumeration value="BND"/>
			<xs:enumeration value="BGL"/>
			<xs:enumeration value="BGN"/>
			<xs:enumeration value="BIF"/>
			<xs:enumeration value="KHR"/>
			<xs:enumeration value="CAD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canadian Dollar. 
						For eBay, you can only specify this currency for listings you submit to the 
						Canada site (site ID 2)
						(Items listed on the Canada site can also specify USD.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CVE"/>
			<xs:enumeration value="KYD"/>
			<xs:enumeration value="XAF"/>
			<xs:enumeration value="CLF"/>
			<xs:enumeration value="CLP"/>
			<xs:enumeration value="CNY">
				<xs:annotation>
					<xs:documentation>
						(in/out) Chinese Yuan Renminbi.
            For eBay, you can only specify this currency for listings you submit to the
						China site (site ID 223).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="COP"/>
			<xs:enumeration value="KMF"/>
			<xs:enumeration value="CDF"/>
			<xs:enumeration value="CRC"/>
			<xs:enumeration value="HRK"/>
			<xs:enumeration value="CUP"/>
			<xs:enumeration value="CYP"/>
			<xs:enumeration value="CZK"/>
			<xs:enumeration value="DKK"/>
			<xs:enumeration value="DJF"/>
			<xs:enumeration value="DOP"/>
			<xs:enumeration value="TPE"/>
			<xs:enumeration value="ECV"/>
			<xs:enumeration value="ECS"/>
			<xs:enumeration value="EGP"/>
			<xs:enumeration value="SVC"/>
			<xs:enumeration value="ERN"/>
			<xs:enumeration value="EEK"/>
			<xs:enumeration value="ETB"/>
			<xs:enumeration value="FKP"/>
			<xs:enumeration value="FJD"/>
			<xs:enumeration value="GMD"/>
			<xs:enumeration value="GEL"/>
			<xs:enumeration value="GHC"/>
			<xs:enumeration value="GIP"/>
			<xs:enumeration value="GTQ"/>
			<xs:enumeration value="GNF"/>
			<xs:enumeration value="GWP"/>
			<xs:enumeration value="GYD"/>
			<xs:enumeration value="HTG"/>
			<xs:enumeration value="HNL"/>
			<xs:enumeration value="HKD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Hong Kong Dollar. 
						For eBay, you can only specify this currency for listings you submit to the
						Hong Kong site (site ID 201).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HUF"/>
			<xs:enumeration value="ISK"/>
			<xs:enumeration value="IDR"/>
			<xs:enumeration value="IRR"/>
			<xs:enumeration value="IQD"/>
			<xs:enumeration value="ILS"/>
			<xs:enumeration value="JMD"/>
			<xs:enumeration value="JPY"/>
			<xs:enumeration value="JOD"/>
			<xs:enumeration value="KZT"/>
			<xs:enumeration value="KES"/>
			<xs:enumeration value="AUD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Australian Dollar. 
						For eBay, you can only specify this currency for listings you submit to the 
						Australia site (site ID 15).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="KPW"/>
			<xs:enumeration value="KRW"/>
			<xs:enumeration value="KWD"/>
			<xs:enumeration value="KGS"/>
			<xs:enumeration value="LAK"/>
			<xs:enumeration value="LVL"/>
			<xs:enumeration value="LBP"/>
			<xs:enumeration value="LSL"/>
			<xs:enumeration value="LRD"/>
			<xs:enumeration value="LYD"/>
			<xs:enumeration value="CHF">
				<xs:annotation>
					<xs:documentation>
						(in/out) Swiss Franc. 
						For eBay, you can only specify this currency for listings you submit to the
						Switzerland site (site ID 193).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LTL"/>
			<xs:enumeration value="MOP"/>
			<xs:enumeration value="MKD"/>
			<xs:enumeration value="MGF"/>
			<xs:enumeration value="MWK"/>
			<xs:enumeration value="MYR">
				<xs:annotation>
					<xs:documentation>
						(in/out) Malaysian Ringgit. 
						For eBay, you can only specify this currency for listings you submit to the
						Malaysia site (site ID 207).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MVR"/>
			<xs:enumeration value="MTL"/>
			<xs:enumeration value="EUR">
				<xs:annotation>
					<xs:documentation>
						(in/out) Euro. 
						For eBay, you can only specify this currency for listings you submit to these sites:
						Austria (site 16), Belgium_French (site 23), 
						France (site 71), Germany (site 77), Italy (site 101), Belgium_Dutch (site 123),
						Netherlands (site 146), Spain (site 186), Ireland (site 205).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MRO"/>
			<xs:enumeration value="MUR"/>
			<xs:enumeration value="MXN"/>
			<xs:enumeration value="MXV"/>
			<xs:enumeration value="MDL"/>
			<xs:enumeration value="MNT"/>
			<xs:enumeration value="XCD"/>
			<xs:enumeration value="MZM"/>
			<xs:enumeration value="MMK"/>
			<xs:enumeration value="ZAR"/>
			<xs:enumeration value="NAD"/>
			<xs:enumeration value="NPR"/>
			<xs:enumeration value="ANG"/>
			<xs:enumeration value="XPF"/>
			<xs:enumeration value="NZD"/>
			<xs:enumeration value="NIO"/>
			<xs:enumeration value="NGN"/>
			<xs:enumeration value="NOK"/>
			<xs:enumeration value="OMR"/>
			<xs:enumeration value="PKR"/>
			<xs:enumeration value="PAB"/>
			<xs:enumeration value="PGK"/>
			<xs:enumeration value="PYG"/>
			<xs:enumeration value="PEN"/>
			<xs:enumeration value="PHP">
				<xs:annotation>
					<xs:documentation>
						(in/out) Philippines Peso. 
						For eBay, you can only specify this currency for listings you submit to the
						Philippines site (site ID 211).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PLN">
				<xs:annotation>
					<xs:documentation>
						(in/out) Poland, Zloty. 
						For eBay, you can only specify this currency for listings you submit to the
						Poland site (site ID 212).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USD">
				<xs:annotation>
					<xs:documentation>
						(in/out) US Dollar. 
						For eBay, you can only specify this currency for listings you submit to the 
						US (site ID 0), eBayMotors (site 100), and Canada (site 2) sites.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QAR"/>
			<xs:enumeration value="ROL"/>
			<xs:enumeration value="RUB"/>
			<xs:enumeration value="RUR"/>
			<xs:enumeration value="RWF"/>
			<xs:enumeration value="SHP"/>
			<xs:enumeration value="WST"/>
			<xs:enumeration value="STD"/>
			<xs:enumeration value="SAR"/>
			<xs:enumeration value="SCR"/>
			<xs:enumeration value="SLL"/>
			<xs:enumeration value="SGD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Singapore Dollar. 
						For eBay, you can only specify this currency for listings you submit to the
						Singapore site (site 216).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SKK"/>
			<xs:enumeration value="SIT"/>
			<xs:enumeration value="SBD"/>
			<xs:enumeration value="SOS"/>
			<xs:enumeration value="LKR"/>
			<xs:enumeration value="SDD"/>
			<xs:enumeration value="SRG"/>
			<xs:enumeration value="SZL"/>
			<xs:enumeration value="SEK">
				<xs:annotation>
					<xs:documentation>
						 (in/out) Swedish Krona. 
						 For eBay, you can only specify this currency for listings you submit to the
						 Sweden site (site 218).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SYP"/>
			<xs:enumeration value="TWD">
				<xs:annotation>
					<xs:documentation>
						(in/out) New Taiwan Dollar. 
						For eBay, you can only specify this currency for listings you submit to the
						Taiwan site (site 196).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TJS"/>
			<xs:enumeration value="TZS"/>
			<xs:enumeration value="THB"/>
			<xs:enumeration value="XOF"/>
			<xs:enumeration value="TOP"/>
			<xs:enumeration value="TTD"/>
			<xs:enumeration value="TND"/>
			<xs:enumeration value="TRL"/>
			<xs:enumeration value="TMM"/>
			<xs:enumeration value="UGX"/>
			<xs:enumeration value="UAH"/>
			<xs:enumeration value="AED"/>
			<xs:enumeration value="GBP">
				<xs:annotation>
					<xs:documentation>
						(in/out) Pound Sterling.
						For eBay, you can only specify this currency for listings you submit to the
						UK site (site ID 3).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USS"/>
			<xs:enumeration value="USN"/>
			<xs:enumeration value="UYU"/>
			<xs:enumeration value="UZS"/>
			<xs:enumeration value="VUV"/>
			<xs:enumeration value="VEB"/>
			<xs:enumeration value="VND"/>
			<xs:enumeration value="MAD"/>
			<xs:enumeration value="YER"/>
			<xs:enumeration value="YUM"/>
			<xs:enumeration value="ZMK"/>
			<xs:enumeration value="ZWD"/>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/CurrencyDetailsType.xsd #####

-->
	<xs:complexType name="CurrencyDetailsType">
		<xs:annotation>
			<xs:documentation> 
				Details about a currency.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Currency abbreviation.&lt;br&gt;&lt;br&gt;
						Related fields:&lt;br&gt;
						Item.Currency and Item.StartPrice in AddItem&lt;br&gt;
						SearchLocationFilter.Currency in GetSearchResults
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Full currency name for display purposes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DataElementSetType.xsd #####

-->
	<xs:complexType name="DataElementSetType">
		<xs:annotation>
			<xs:documentation>
Container for a set of data elements (see below) that are applicable for a set
of products that were returned within the same response. The data elements contain
supplemental information that can help end users understand product search results.
Usage of this information is optional and may require developers to inspect
the information to determine how it can be applied in an application.
Output only.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DataElement" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						An HTML snippet that specifies hints for the user, help links, help graphics, 
						and other supplemental information that varies per characteristic set.
						In GetProductSearchPage, one DataElement value contains a hint (including an empty HTML achor element),
						one DataElement value may contain a URL to insert into the HTML anchor as the href value,
						and one DataElement value may contain a URL that eBay uses as a help graphic.
						If no value is available in the meta-data, a dash ("--") is returned instead.
						Usage of this information is optional and may require developers to inspect 
						the information to determine how it can be applied in an application. 
						Because this is returned as a string, the HTML markup elements are escaped with 
						character entity references (e.g.,&amp;lt;a href=""&amp;gt;&amp;lt;Attributes&amp;gt;...). 
						See the appendices in the eBay Web Services guide for general information about 
						string data types.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DataElementID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Identifier for a data element. This is primarily for internal use by eBay.
						Developers can choose to inspect this information and determine how it 
						can be applied in their applications.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="attributeSetID" type="xs:int">
			<xs:annotation>
				<xs:documentation>
					Matches the AttributeSetID associated with a response
					returned from the same call that returned the data element set.
					As calls like GetProductSearchResults can perform batch searches, this ID helps
					you determine which attribute set the data element set is associated with.
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DateSpecifierCodeList.xsd #####

-->
	<xs:simpleType name="DateSpecifierCodeType">
		<xs:annotation>
			<xs:documentation>
				 Specifies a subcomponent of a date. Useful in cases when it is
				 helpful to allow separate text fields or drop-down lists to be
				 rendered for each date subcomponent. (For example, when calling
				 GetProductSearchResults, you use date specifiers to indicate the
				 date subcomponent that the attribute represents.)
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="M">
				<xs:annotation>
					<xs:documentation>
						(in/out) The month subcomponent of a date.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="D">
				<xs:annotation>
					<xs:documentation> 
						(in/out) The day subcomponent of a date.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Y">
				<xs:annotation>
					<xs:documentation> 
						(in/out) The year subcomponent of a date.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DepositTypeCodeList.xsd #####

-->
	<xs:simpleType name="DepositTypeCodeType">
		<xs:annotation>
			<xs:documentation>
DepositTypeCodeType - Type declaration to be used by other schema.
For vehicles listed through the US eBay Motors site, DepositType 
indicates how the buyer should pay the deposit amount. It is 
used in conjunction with a buyer payment method (BuyerPaymentMethodCodeType).
If the item listed is not a US eBay Motors item, the DepositType value 
is returned as "None".
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
					  (in/out) No deposit needed
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OtherMethod">
				<xs:annotation>
					<xs:documentation>
					  (in/out) Pay the deposit using one of the specified
					  PaymentMethods (BuyerPaymentMethodCodeType)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FastDeposit">
				<xs:annotation>
					<xs:documentation> 
					   (in/out) No longer in use (defaults to OtherMethod)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DescriptionTemplateCodeList.xsd #####

-->
	<xs:simpleType name="DescriptionTemplateCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="Layout">
				<xs:annotation>
					<xs:documentation>
						The template details establish how pictures are to be
						positioned relative to the description text.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Theme">
				<xs:annotation>
					<xs:documentation>
						The template determines which eBay-provided theme (e.g. 
						Valentine's Day) is to be applied for presenting pictures
						and description text.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DescriptionTemplateType.xsd #####

-->
	<xs:complexType name="DescriptionTemplateType">
		<xs:annotation>
			<xs:documentation>
				The information for one Theme or one Layout.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="GroupID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for the group in which a Theme falls 
						(holidays, special events, etc.). Not returned for Layouts.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for one Theme or Layout.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ImageURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						URL for a small (100x120 pixel) image providing a sample of how a Theme or Layout looks.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique text name of the Theme or Layout.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TemplateXML" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						XML defining the template. Elements you must include
						in your XML: ThemeTop, ThemeUserCellTop, ThemeUserContent, 
						ThemeUserCellBottom, ThemeBottom. Not returned for Layouts.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Type" type="ns:DescriptionTemplateCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Either Layout or Theme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DetailNameCodeList.xsd #####

-->
	<xs:simpleType name="DetailNameCodeType">
		<xs:annotation>
			<xs:documentation>
				A designation of what kind of information you wish returned by
				GeteBayDetails for the specified eBay site.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="CountryDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific country.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CurrencyDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific currency.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentOptionDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific payment option.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RegionDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific geographical area.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingLocationDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific location or region to which the
						seller is willing to ship.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingServiceDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific shipping service.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SiteDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific eBay site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TaxJurisdiction">
				<xs:annotation>
					<xs:documentation>
						Details about a specific tax jurisdiction or region.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="URLDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific eBay URL.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DispatchTimeMaxDetails">
				<xs:annotation>
					<xs:documentation>
						Details about a specific maximum dispatch time. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DeviceTypeCodeList.xsd #####

-->
	<xs:simpleType name="DeviceTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				The means of receipt of notification.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Platform">
				<xs:annotation>
					<xs:documentation>
						Typical API, web page interaction.
					</xs:documentation>
					<xs:appinfo>
					  <CallInfo>
					    <CallName>SetNotificationPreferences</CallName>
					    <RequiredInput>No</RequiredInput>
					  </CallInfo>
					  <CallInfo>
					    <CallName>GetNotificationPreferences</CallName>
					    <Returned>Conditionally</Returned>
					  </CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SMS">
				<xs:annotation>
					<xs:documentation>
						For SMS/wireless application.
					</xs:documentation>
					<xs:appinfo>
					  <CallInfo>
					    <CallName>SetNotificationPreferences</CallName>
					    <RequiredInput>No</RequiredInput>
					  </CallInfo>
					  <CallInfo>
					    <CallName>GetNotificationPreferences</CallName>
					    <Returned>Conditionally</Returned>
					  </CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DigitalDeliveryDetailsType.xsd #####

-->
	<xs:complexType name="DigitalDeliveryDetailsType">
		<xs:sequence>
			<xs:element name="Requirements" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						File type, operating system specifications,
						or other requirements for using the digital item.
						In this section, specify the following information about your digital item, if applicable:&lt;br&gt;
						- Type of file (file format). Examples include MP3, MOV, etc.&lt;br&gt;
						- Any computer hardware or software requirements. For example, is your file compatible with both PCs and Macintosh computers?
							Will it work with all operating systems (Windows XP, Windows 2000, Mac OS X, etc.)?
							Does the buyer need a specific software program, such as Microsoft Word, to use the item?&lt;br&gt;
						- Any other requirements. For example, does the buyer need to provide an email address where you will send the item?&lt;br&gt;
						For example: "Adobe PDF (Portable Document Format) file;
						buyer will need Adobe Acrobat Reader 5.0 or higher and 5MB of available hard-disk space."
						Be as specific as possible so that buyers know exactly what they need to access and use
						the item successfully. This information will appear in your listing so that buyers can
						make an informed purchase decision.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSearchResults</CallName>
							<!-- N/A to GetItemTransactions, GetSellerTransactions, GetOrderTransactions -->
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Method" type="ns:DigitalDeliveryMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The digital download method.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSearchResults</CallName>
							<!-- N/A to GetItemTransactions, GetSellerTransactions, GetOrderTransactions -->
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The download URL for the digital item. Provide a Web address for your digital item that uses
						one of the following protocols: HTTP, HTTPS, or FTP. If you do not have a Web address that meets these criteria,
						specify alternate delivery information in the Instructions field instead.
						The information will be displayed to the buyer only after payment has been confirmed.
						Required if Method value is DownloadURL.
						Ignored if Method value is AlternateDeliveryInstructions (or None).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<!-- N/A to GetItemTransactions, GetSellerTransactions, GetOrderTransactions -->
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Instructions" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Text instructions for accessing the digital item. For example, if no delivery URL
						is provided, the seller may ask the buyer to specify an email address when they pay for the item so that
						the seller can send the file to the buyer. If a Web address is specified in URL,
						the seller may provide instructions on using the Web address.
						The text will be displayed as is (so do not pass in HTML or Javascript).
						The information will be displayed to the buyer only after payment has been confirmed.
						Required if Method value is AlternateDeliveryInstructions.
						Optional if Method value is DownloadURL and a DownloadURL value is specified.
						Ignored if Method value is None.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500 (characters)</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<!-- N/A to GetItemTransactions, GetSellerTransactions, GetOrderTransactions -->
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DigitalDeliveryEnabledCodeList.xsd #####

-->
	<xs:simpleType name="DigitalDeliveryEnabledCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="Disabled">
				<xs:annotation>
					<xs:documentation>
						The digital delivery listing option is disabled for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Enabled">
				<xs:annotation>
					<xs:documentation>
					The digital delivery listing option is available in this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Promoted">
				<xs:annotation>
					<xs:documentation>
					The digital delivery listing option is available in this category, 
					and eBay normally displays this option by default in this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode"/>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DigitalDeliveryEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="DigitalDeliveryEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				If the field is present, the digital delivery feature applies to the category. 
				If applicable, the field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DigitalDeliveryMethodCodeList.xsd #####

-->
	<xs:simpleType name="DigitalDeliveryMethodCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
					The item cannot be downloaded.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>			
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DownloadURL">
				<xs:annotation>
					<xs:documentation>
					The item can be downloaded by using a URL.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>			
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AlternateDeliveryInstructions">
				<xs:annotation>
					<xs:documentation>
					The item can be downloaded according to instructions specified by the seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>			
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode"/>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DispatchTimeMaxDetailsType.xsd #####

-->
	<xs:complexType name="DispatchTimeMaxDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details about a specific maximum dispatch time, the maximum number of business 
				days required to ship an item to domestic buyers after receiving a cleared 
				payment.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DispatchTimeMax" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Integer value (1, 2, 3, 4, 5, 10, 15, or 20) corresponding to the 
						maximum dispatch time. &lt;br&gt;&lt;br&gt;
						Related field:&lt;br&gt;
						Item.DispatchTimeMax in AddItem
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Value and unit (e.g., 10 Days) for the maximum dispatch time.
						Useful for display purposes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DisplayPayNowButtonCodeList.xsd #####

-->
	<xs:simpleType name="DisplayPayNowButtonCodeType">
		<xs:annotation>
			<xs:documentation>
				Ways to Display PayNow Button
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ShowPayNowButtonForAllPaymentMethods">
				<xs:annotation>
					<xs:documentation>
						 Show PayNow Button For All Payment Methods
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShowPayNowButtonForPayPalOnly">
				<xs:annotation>
					<xs:documentation>
						 Show PayNow Button For PayPal Only
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						 Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/DisputeArrayType.xsd #####

-->
	<xs:complexType name="DisputeArrayType">
		<xs:annotation>
			<xs:documentation>
				Represents a list of disputes. Can hold zero or more Dispute
				types, each of which describes a dispute.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Dispute" type="ns:DisputeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The information that describes a dispute, including
						the buyer's name, the transaction ID, the dispute state
						and status, whether the dispute is resolved,
						and any messages posted to the dispute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DisputeType.xsd #####

-->
	<xs:complexType name="DisputeType">
		<xs:annotation>
			<xs:documentation>
				Contains all information describing a dispute.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DisputeID" type="ns:DisputeIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The unique identifier of a dispute, returned by the eBay site
						when the dispute is created.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeRecordType" type="ns:DisputeRecordTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The type of dispute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeState" type="ns:DisputeStateCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The internal state of the dispute. The value determines
						which values of DisputeActivity are valid when responding
						to a dispute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeStatus" type="ns:DisputeStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The status of the dispute, which provides additional
						information about the dispute state.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="OtherPartyRole" type="ns:TradingRoleCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The role of the person involved in the dispute who is
						not taking action or requesting information. The role is
						either Buyer or Seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="OtherPartyName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The user name of the person involved in the dispute who
						is not taking action or requesting information. The role is
						either Buyer or Seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserRole" type="ns:TradingRoleCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  The role of the person involved in the dispute who is taking action or
					  requesting information. The role is either Buyer or Seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerUserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The eBay user ID of the buyer involved in the dispute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerUserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The eBay user ID of the seller involved in the dispute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The unique identifier of the transaction under dispute.
						The transaction is created when the winning bidder commits to
						purchasing the item but before the bidder pays.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Item" type="ns:ItemType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Information about the item that spawned the transaction.
						The transaction is a purchase from this item's listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeReason" type="ns:DisputeReasonCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The top-level reason for the dispute. The value of DisputeReason
						determines which values of DisputeExplanation are valid.
						See DisputeExplanationCodeList for details.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeExplanation" type="ns:DisputeExplanationCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The detailed explanation for the dispute. Valid values
						depend on the value of DisputeReason. See DisputeExplanationCodeList
						for details.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeCreditEligibility" type="ns:DisputeCreditEligibilityCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether the dispute is currently eligible for Final Value Fee credit.
						The value is usually Ineligible until 7 days after the
						dispute was created, unless a fee exception applies.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeCreatedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time the dispute was created, in GMT.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeModifiedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time the dispute was modified, in GMT.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeResolution" type="ns:DisputeResolutionType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The action resulting from the dispute resolution. The
						action might include a Final Value Fee credit to the seller, a strike
						to the buyer, a reversal, or an appeal.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisputeMessage" type="ns:DisputeMessageType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A response or message posted to a dispute, either by
						an application or by a user on the eBay site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Escalation" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether the buyer can close a dispute unhappy and escalate it
						to the eBay Standard Purchase Protection Program. To escalate, the buyer
						must be eligible for the PPP. Used in Item Not Received disputes.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PurchaseProtection" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether the buyer is eligible for the eBay Standard Purchase Protection
						Program. The eligibility rules are described in the eBay site online help.
						Used in Item Not Received disputes.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DistanceType.xsd #####

-->
	<xs:complexType name="DistanceType">
		<xs:annotation>
			<xs:documentation>
			 	DistanceType used in proximity search
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DistanceMeasurement" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						The measurement used in a proximity search distance calculation.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DistanceUnit" minOccurs="0" type="xs:string" >
				<xs:annotation>
					<xs:documentation>
						The unit used in a proximity search distance calculation.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DomainHistogramType.xsd #####

-->
	<xs:complexType name="DomainHistogramType">
		<xs:annotation>
			<xs:documentation> 
Container for a list of Express departments, aisles, and/or products. 
Can contain zero, one, or multiple ExpressHistogramDepartmentType objects.
        		</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Department" type="ns:ExpressHistogramDepartmentType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
					Contains item and product counts for a department, aisles, and/or Express product types.
					Only returned when HistogramDetails is configured to retrieve histogram data.
					Multiple Department nodes can be returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/DutchBINEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="DutchBINEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the DutchBINEnabled feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/EBaySubscriptionTypeCodeList.xsd #####

-->
	<xs:simpleType name="EBaySubscriptionTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="SellerAssistant">
				<xs:annotation>
					<xs:documentation>
				      </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerAssistantPro">
				<xs:annotation>
					<xs:documentation> 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EBayStoreBasic">
				<xs:annotation>
					<xs:documentation> 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EBayStoreFeatured">
				<xs:annotation>
					<xs:documentation> 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EBayStoreAnchor">
				<xs:annotation>
					<xs:documentation> 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellingManager">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellingManagerPro">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel1">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel2">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel3">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel4">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel5">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel6">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManagerLevel7">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReportsBasic">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerReportsPlus">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FileExchange">
				<xs:annotation>
					<xs:documentation>
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketSpecialty">
				<xs:annotation>
					<xs:documentation>
						Allowed categories are Motorcycles, Powersports, and Other Vehicles.
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketRegular">
				<xs:annotation>
					<xs:documentation>
						In addition to the categories allowed by LocalMarketSpecialty, allows 
						Passenger Vehicles.
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketPremium">
				<xs:annotation>
					<xs:documentation>
						Allows same categories as LocalMarketRegular.
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/EnableCodeList.xsd #####

-->
	<xs:simpleType name="EnableCodeType">
		<xs:annotation>
			<xs:documentation>
				The status of a particular entry.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Enable">
				<xs:annotation>
					<xs:documentation>
						(in/out) The entry is enabled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Disable">
				<xs:annotation>
					<xs:documentation>
						(in/out) The entry is disabled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/EndOfAuctionEmailPreferencesType.xsd #####

-->
	<xs:complexType name="EndOfAuctionEmailPreferencesType">
		<xs:annotation>
			<xs:documentation>Contains the seller's preferences for the end of auction (EOA) email to the buyer.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TemplateText" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The text of the custom message for the end of auction (for auctions) or end of transaction (for Buy It Now) emails. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LogoURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The URL of the logo to include in the customized email.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LogoType" type="ns:EndOfAuctionLogoTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The type of logo to include in the customized email.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="EmailCustomized" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether or not the seller wishes to send a customized email to winning buyers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TextCustomized" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether or not the text of the customized message will be customized.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LogoCustomized" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether or not the seller wishes to include a logo in the customized email.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CopyEmail" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether or not the seller wishes to receive a copy of the customized email sent to the winning buyer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/EndOfAuctionLogoTypeCodeList.xsd #####

-->
	<xs:simpleType name="EndOfAuctionLogoTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			EndOfAuctionLogoTypeCodeType - Type declaration to be used by other schema. 
			Indicatest the type of logo to be used in a customize end of auction (EOA) email.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="WinningBidderNotice">
				<xs:annotation>
					<xs:documentation>
					 The PayPal Winning Bidder Notice logo.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Store">
				<xs:annotation>
					<xs:documentation>
					 The eBay Store logo.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Customized">
				<xs:annotation>
					<xs:documentation>
					 A customized logo specified in LogoURL.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					  Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates that no logo has been specified for use in the end of auction 
						(EOA) email.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/EndReasonCodeList.xsd #####

-->
	<xs:simpleType name="EndReasonCodeType">
		<xs:annotation>
			<xs:documentation>
           ReasonCodeType - Type declaration to be used by other schema.
           Specifies the seller's reason for ending an item listing early. This
           is required if the seller ended the listing early and the item did
           not successfully sell.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="LostOrBroken">
				<xs:annotation>
					<xs:documentation>
                (in) The item was lost or broken.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>EndItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotAvailable">
				<xs:annotation>
					<xs:documentation>
                (in) The item is no longer available for sale.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>EndItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Incorrect">
				<xs:annotation>
					<xs:documentation>
                (in) The minimum bid or reserve price is incorrect.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>EndItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OtherListingError">
				<xs:annotation>
					<xs:documentation>
                (in) The listing contained an error (other than minimum bid or reserve
                price).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>EndItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/EscrowCodeList.xsd #####

-->
	<xs:simpleType name="EscrowCodeType">
		<xs:annotation>
			<xs:documentation>
EscrowCodeType - Type declaration to be used by other schema. Indicates whether
escrow is used for a listing.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ByBuyer">
				<xs:annotation>
					<xs:documentation>
						    (in/out) By Buyer
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BySeller">
				<xs:annotation>
					<xs:documentation>
						   (in/out) By Seller
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						   (in/out) None
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExpansionArrayType.xsd #####

-->
	<xs:complexType name="ExpansionArrayType">
		<xs:annotation>
			<xs:documentation> 
				Container for items returned with an expanded search.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ExpansionItem" type="ns:SearchResultItemType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Item that is the result of an expanded search. If, in a GetSearchResults 
						request, you specify true for ExpandSearch, the search is expanded when a 
						small result set is returned. For example, on the US site (site ID 0), if a 
						search would normally result in fewer than 10 items, then the search results 
						are expanded. Specifically, the search returns items (if there are matches) 
						in one or more of the following containers: InternationalExpansionArray (for 
						items available from international sellers), FilterRemovedExpansionArray 
						(items that would be returned if filters such as PriceRangeFilter are 
						removed), and AllCategoriesExpansionArray (for items available if category 
						filters are removed). The maximum number of items returned in each container 
						is 6 to 10.	
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  The number of matching items available under the expansion.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressConditionRequiredDefinitionType.xsd #####

-->
	<xs:complexType name="ExpressConditionRequiredDefinitionType">
		<xs:annotation>
			<xs:documentation> 
For the US and Germany sites, an eBay item must meet a number of eligibility requirements 
in order to also be included on eBay Express. 
One requirement is that the item must include the Item Condition attribute (using Item Specifics).
Some categories may waive this requirement.
Currently, this type defines no special meta-data. (An empty element is returned.)
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressDetailLevelCodeList.xsd #####

-->
	<xs:simpleType name="ExpressDetailLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				For GetSearchResultsExpress, controls the details to retrieve per
				item, product, or histogram.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Coarse">
				<xs:annotation>
					<xs:documentation>
						(in) The effect of Coarse varies for HistogramDetails, ProductDetails,
						and ItemDetails.&lt;br&gt;
						&lt;br&gt;
						For HistogramDetails, this is primarily useful for reducing the
						histogram depth when you search across all departments or within a
						specific department. (When you search by AisleName or ProductTypeName,
						there is no difference between Coarse and Fine).&lt;br&gt;
						&lt;br&gt;
						If the request includes no DepartmentName, AisleName, or ProductName,
						retrieve a histogram for all departments that match the
						criteria in the request, but don't retrieve aisle or
						product type details.
						Stand-alone domains (aisles and product types) aren't grouped into
						departments, so Express ignores them in this departments-only histogram.
						That is, the data in the histogram is only based on matching departments
						and their grouped subdomains.
						(Please note the following consequences of retrieving a departments-only
						histogram:
						If Express only finds items or products in stand-alone domains,
						then ItemCount or ProductCount could be 0. For example, if Express finds
						catalog products in two departments, but only finds items in a
						stand-alone product type (like DVDs &amp; Movies),
						ItemCount would be 0 in the two departments.
						Furthermore, if all matching items and catalog products are in
						stand-alone domains, no histogram is returned at all (because there are
						no matching departments). This might occur when you also add filters
						(e.g., LowestPrice) or more query keywords to your request.)&lt;br&gt;
						&lt;br&gt;
						If the request only specifies DepartmentName, retrieve a histogram
						for that department and all of its aisles (but no histogram details
						for any product types it contains).
						If the request only specifies AisleName, retrieve the full histogram
						for that aisle, including all of its product types and the
						parent department.
						If the request only specifies ProductTypeName, retrieve the histogram
						for its parent department (and any aisles), or only retrieve the
						histogram for the product type if isn't grouped into
						a department.&lt;br&gt;
						&lt;br&gt;
						For ProductDetails, retrieve the Title, MinPrice, and MaxPrice fields
						for each product found.&lt;br&gt;
						&lt;br&gt;
						For ItemDetails, retrieve the ItemID, Title, BuyItNowPrice,
						and ShippingDetails node for each item found.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Fine">
				<xs:annotation>
					<xs:documentation>
						(in) For HistogramDetails, retrieve a full histogram (all levels of the
						domain hierarchy) that matches the request.
						If you specify Fine, you must also specify DepartmentName, AisleName,
						and/or ProductTypeName in the request.
						If the request only specifies DepartmentName, retrieve a full histogram
						for that department, all of its aisles, and all of its product types.
						If the request only specifies AisleName or ProductTypeName, the results
						are the same as specifying Coarse.&lt;br&gt;
						&lt;br&gt;
						For ProductDetails, retrieve all applicable fields for each
						catalog product found.&lt;br&gt;
						&lt;br&gt;
						For ItemDetails, retrieve all applicable fields for each item found.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(in) For HistogramDetails, omits the histogram from the response.
						For ProductDetails, omits the ProductArray from the response.
						For ItemDetails, omits the ItemArray from the response.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExpressDetailsType.xsd #####

-->
	<xs:complexType name="ExpressDetailsType">
		<xs:annotation>
			<xs:documentation>
Item details that are only applicable to listings on Express (not the main eBay site).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ExpressLargeImage" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					Large gallery image that appears in the "Grid View" in search results on the Express site.
					The longest dimenstion  is 140 pixels.
					Only returned when ItemDetails is set to Fine.&lt;br&gt;
					&lt;br&gt;
					Express generates the image based on pictures that the seller includes in 
					the listing. For details about Express listing criteria, see the 
					"eBay Express" section of the eBay Web Services Guide.&lt;br&gt;
					&lt;br&gt;
					If the item was listed in an eBay category that does not require 
					pictures for Express (like Tickets), a generic image may be returned instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressSmallImage" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Small gallery image that appears in the "List View" in search results on the Express site.
					The longest dimenstion is 96 pixels.
					Only returned when ItemDetails is set to Fine.&lt;br&gt;
					&lt;br&gt;
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Condition" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					The item condition, if any. On Express US, this is often a value like "New", "Used", or "Refurbished",
					but the exact value can vary based on the Item Condition data that the seller used in the listing.&lt;br&gt;
					For example, in some eBay categories, the condition can have a value like "New: With Tags" instead.
					(At the time of this writing, GetSearchResultsExpress mapped all conditions to "New" and "Used".
					However, this could change in the future.)
					By default, only new items (or the equivalent) are returned from GetSearchResultsExpress.
					Use Condition in the request to include used and refurbished items (or the equivalent) as well.
					Only returned when ItemDetails is set to Fine.&lt;br&gt;
					&lt;br&gt;
					Not applicable to calls that browse or search items on the main eBay site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="ExpressEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
For the US and Germany sites, an eBay item must meet a number of eligibility requirements 
in order to also be included on eBay Express. 
One requirement is that the category needs to support Express.
Currently, this type defines no special meta-data. (An empty element is returned.)
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressHistogramAisleType.xsd #####

-->
	<xs:complexType name="ExpressHistogramAisleType">
		<xs:annotation>
			<xs:documentation>
				Details about an Express aisle and matching item and catalog product counts 
				in that aisle, if any.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DomainDetails" type="ns:ExpressHistogramDomainDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					Identifies the aisle and provides matching item and 
					eBay catalog product counts in the specified aisle, if any.
					Only returned if an aisle matched the request.&lt;br&gt;
					&lt;br&gt;
					If this node is missing but Aisle.ProductType is present, it means that the 
					product type specified in Aisle.ProductType is not grouped into an aisle.
					In the Express Web site UI, such product types are elevated to (treated as) aisles
					from the user's perspective (or as Departments, if Department.DomainDetails is also missing).
					However, the API always maintains the Department/Aisle/ProductType
					structure to help you distinguish between actual departments, aisles, and stand-alone product types.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductType" type="ns:ExpressHistogramProductType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
						Contains item and catalog product counts for an Express product type.
						Only returned when HistogramDetails is configured to return product types.&lt;br&gt;
						&lt;br&gt;
						An Aisle node can contain multiple ProductType nodes. 
            </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressHistogramDepartmentType.xsd #####

-->
	<xs:complexType name="ExpressHistogramDepartmentType">
		<xs:annotation>
			<xs:documentation>
				Details about an Express department and matching item and catalog product counts 
				in that department, if any.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DomainDetails" type="ns:ExpressHistogramDomainDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					Identifies the department and provides matching item and 
					eBay catalog product counts in the specified department.
					Only returned if a department matched the request.&lt;br&gt;
					&lt;br&gt;
					If this node is missing but Department.Aisle.ProductType is present, it means that the product type 
					specified in Department.Aisle.ProductType is not grouped into a department.
					In the Express Web site UI, stand-alone product types are elevated to (treated as) departments
					from the user's perspective. However, the API always maintains the Department/Aisle/ProductType
					structure to help you distinguish between actual departments, aisles, and stand-alone product types.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Aisle" type="ns:ExpressHistogramAisleType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
					Contains item and catalog product counts for an aisle (if any) and may contain a list of product types.
					Only returned when HistogramDetails is configured to return aisles and/or product types.&lt;br&gt;
						&lt;br&gt;
						A Department node can contain multiple Aisle nodes. 
            			</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressHistogramDomainDetailsType.xsd #####

-->
	<xs:complexType name="ExpressHistogramDomainDetailsType">
		<xs:annotation>
			<xs:documentation>
				Identifies a domain and provides statistics for items and
				catalog products found in that domain.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The domain name, with no spaces.
					Use this to determine DepartmentName, AisleName, and/or ProductTypeName
					values to pass in the request.&lt;br&gt;
					&lt;br&gt;
					Note: The potential max length will be documented in a future release.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BreadCrumb" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The fully qualified display name of the domain, as it would appear in the
					Express Web site user interface.
					For example, a fully qualified aisle breadcrumb would include the
					department's display name and the aisle's display name.
					The names can contain spaces, and a greater-than character ("&gt;") is used
					as the delimiter; for example:
					Consumer Electronics &gt; Cell Phones &amp; PDAs &gt; PDA Accessories.
					As with all string data types, reserved characters like "&gt;" are escaped
					in the raw response.&lt;br&gt;
					&lt;br&gt;
					Note: The potential max length will be documented in a future release.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The number of matching items that were found in the
					specified department, aisle, or product type.&lt;br&gt;
					&lt;br&gt;
					If HistogramDetails==Coarse and you don't specify
					DepartmentName, AisleName, or ProductTypeName in the request,
					Express only counts items found in matching departments.
					In this particular case, ItemCount could be 0 in all domain histogram
					results when the only matching items are in stand-alone product types
					or aisles (because they aren't grouped into departments).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The number of matching eBay catalog products that were found in the
					specified department, aisle, or product type.&lt;br&gt;
					&lt;br&gt;
					If HistogramDetails==Coarse and you don't specify
					DepartmentName, AisleName, or ProductTypeName in the request,
					Express only counts catalog products found in matching departments.
					In this particular case, ProductCount could be 0 in all domain histogram
					results when the only matching catalog products are in
					stand-alone product types or aisles (because they aren't
					grouped into departments).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ImageURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The image associated with the department, aisle, or product, if any.
					All domains should be associated with an image. However, there may be
					rare cases when an image is not available.
            	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressHistogramProductType.xsd #####

-->
	<xs:complexType name="ExpressHistogramProductType">
		<xs:annotation>
			<xs:documentation>
				Details about an Express product type and matching item and catalog product counts 
				in that product type, if any.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DomainDetails" type="ns:ExpressHistogramDomainDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					Identifies an Express product type and provides item and 
					eBay catalog product counts in that product type.
					Only returned if a product type matched the request.&lt;br&gt;
					&lt;br&gt;
					A product type domain can stand alone, or it can be grouped with other product types into 
					an aisle or a department.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressHistogramSortCodeList.xsd #####

-->
	<xs:simpleType name="ExpressHistogramSortCodeType">
		<xs:annotation>
			<xs:documentation>
Sort options for the Express histogram.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ItemCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the domains in the histogram by the item count in descending order. 
						The domain with the most matching items is returned first.
						This is the default setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProductCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the domains by the product count in descending order.
						The domain with the most matching products is returned first.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Alphabetical">
				<xs:annotation>
					<xs:documentation>
					(in) Sort the domains alphabetically by DomainDetails.Name.
					Domains at the same depth are sorted first. Within each domain,
					child domains are also sorted. For example, a "Books_Dept" department
					and its aisles or product types would be returned before a 
					stand-alone "Hard_Domain_Music" product type.  
					And that "Hard_Domain_Music" product type would be returned before 
					a stand-alone "OldNavyAisle" aisle and its product types.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExpressItemSortCodeList.xsd #####

-->
	<xs:simpleType name="ExpressItemSortCodeType">
		<xs:annotation>
			<xs:documentation>
Sorts the items in the ItemArray.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="LowestTotalCost">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the items by the lowest total cost, including shipping. 
						The item with the lowest total cost is returned first.
						To calculate the total cost, PostalCode must also be specified in the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HighestTotalCost">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the items by the highest total cost, including shipping. 
						The item with the highest total cost is returned first.
						To calculate the total cost, PostalCode must also be specified in the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Relevance">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the items by relevance. This is the default.
						The item with the highest relevance is returned first.
						The relevance is determined by various factors, such as matching item details
						and historical buyer behavior.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                			(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExpressPicturesRequiredDefinitionType.xsd #####

-->
	<xs:complexType name="ExpressPicturesRequiredDefinitionType">
		<xs:annotation>
			<xs:documentation> 
For the US and Germany sites, an eBay item must meet a number of eligibility requirements 
in order to also be included on eBay Express. 
One requirement is that the item must include a picture (or gallery image).
Currently, this type defines no special meta-data. (An empty element is returned.)
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressPreferencesType.xsd #####

-->
	<xs:complexType name="ExpressPreferencesType">
		<xs:annotation>
			<xs:documentation>
			Contains a seller's preferences related to listing items on Express.
		</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ExpressSellingPreference" type="ns:ExpressSellingPreferenceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Specifies the kinds of eligible listings the seller wants to include on Express.
					Some values are only applicable to certain sites.
					Only applicable to sellers who are eligible to list on Express.&lt;br&gt;
					&lt;br&gt;
					For the US site, if the seller opts out of Express, their listings are immediately removed
					from Express. (Please note that other changes that affect a user or item's eligibility
					can take up to 7 days to be reflected.)
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>omitted</Default>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DefaultPayPalAccount" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					&lt;b&gt;Coming soon:&lt;/b&gt; For eBay Germany users only.
					The PayPal account (email address) to use for eBay Express payments during checkout.
					If the first item in an order doesn't specify a PayPal account,
					Express Germany uses this default PayPal account for the item.
					(The account specified for the first item
					is used for all items in the same order.)&lt;br&gt;
					&lt;br&gt;
					This default account is only used for Express payments during checkout;
					it has no effect on item data.
					(To specify a default PayPal account for items, use the PayPal fields in
					the SellerPaymentPreferences node.)&lt;br&gt;
					&lt;br&gt;
					Only applicable to sellers who are qualified to list on Express Germany.
					Call GetUser to determine the seller's Express eligibility.
					&lt;br&gt;
					&lt;br&gt;
					When you set this value using SetUserPreferences, eBay validates that the
					PayPal account qualifies for Express. We check that the account
					is in good standing, it is a Business or Premier account,
					and it does not block unconfirmed addresses.
					This means the seller needs to configure their PayPal account correctly
					before calling SetUserPreferences.&lt;br&gt;
					&lt;br&gt;
					&lt;span class="tablenote"&gt;&lt;b&gt;Note:&lt;/b&gt; If the PayPal account
					becomes ineligible later (e.g., the seller blocks unconfirmed addresses),
					GetUserPreferences still returns the specified email address. Therefore, the existence of
					this preference in GetUserPreferences does not guarantee that the specified address is valid for Express.
					When a PayPal account becomes ineligible, Express reevaluates the eligibility of the
					seller and their items, and may remove the seller's items from Express.
					See the eBay Web Services guide links below for more information.&lt;/span&gt;&lt;br&gt;
					&lt;br&gt;
					This preference does not control the seller's eligibility for Express.
					However, it can control an item's eligibility in some cases.
					That is, for a fixed-price or Store Inventory item to be eligible for Express Germany,
					either the item or this Express preference must
					specify a valid PayPal email address. (For other eligibility requirements,
					see the eBay Web Services guide.)&lt;br&gt;
					&lt;br&gt;
					In GetUserPreferences, this preference is only returned if a default PayPal account has been specified.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>eBay Express</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=eBayExpress</URL>
						</SeeLink>
						<SeeLink>
							<Title>Listing Criteria for eBay Express</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressListingCriteria</URL>
						</SeeLink>
						<SeeLink>
							<Title>(AddItem) Item.PayPalEmailAddress</Title>
							<URL>io_AddItem.html#Request.Item.PayPalEmailAddress</URL>
						</SeeLink>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
							<SeeLink>
								<Title>SellerPaymentPreferences node</Title>
								<URL>#Response.SellerPaymentPreferences</URL>
							</SeeLink>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>omitted</Default>
							<SeeLink>
								<Title>SellerPaymentPreferences node</Title>
								<URL>#Request.SellerPaymentPreferences</URL>
							</SeeLink>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressProductSortCodeList.xsd #####

-->
	<xs:simpleType name="ExpressProductSortCodeType">
		<xs:annotation>
			<xs:documentation>
Sorts the products in ProductArray.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="LowestPrice">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the products by the lowest current price of the items available. 
						The product with the lowest-priced item is returned first.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>			
			<xs:enumeration value="HighestPrice">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the products by the highest current price of the items available. 
						The product with the highest-priced item is returned first.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SalesRank">
				<xs:annotation>
					<xs:documentation>
						(in) Sort the products by sales rank. 
						The product with the highest sales rank (i.e., the best-selling product) 
						is returned first.
						The rules that are used to determine the sales rank vary for 
						each product type and are not disclosed in this documentation.
						However, in general, the sales rank is based on the number of items sold 
						on Express and/or the main eBay site.
						This is the default.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>			
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExpressProductType.xsd #####

-->
	<xs:complexType name="ExpressProductType">
		<xs:annotation>
			<xs:documentation>
			Information that eBay Express collects about an eBay catalog product.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						The title of the eBay catalog product. Always returned when Product is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Lowest current price of active and ended listings on the specified eBay site that were
						pre-filled based on the eBay catalog product. The value is in the Express site's currency
						(i.e., the price is not converted).
						Round numbers might only show one zero after the decimal (e.g., 15.0).
						Always returned when Product is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Highest current price of active and ended listings on the specified eBay site that were
						pre-filled based on this product. The value is in the Express site's currency
						(i.e., the price is not converted).
						Round numbers might only show one zero after the decimal (e.g., 15.0).
						Always returned when Product is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StockPhotoURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Fully qualified URL for a stock image (if any) that is associated with the 
						eBay catalog product. Only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Total number of active listings (on the specified Express site)
					that were pre-filled based on this eBay catalog product.
					Only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					An ISBN or UPC value (if any) that is associated with this eBay catalog product.
					Only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductReferenceID" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The Express reference ID for an eBay catalog product (if any) that was used to pre-fill 
					the listing's Item Specifics and other details. 
					Only returned when ProductDetails is set to Fine.&lt;br&gt;
					&lt;br&gt;
					&lt;b&gt;Note: &lt;/b&gt; This value is not the same as the ProductID used in AddItem and related calls.
					You cannot use this call or the catalog search calls to determine a relationship between 
					this reference ID and the eBay catalog ProductID that is used for listing on eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemSpecifics" type="ns:NameValueListArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A list of attribute and value pairs that are included in the product's 
						pre-filled Item Specifics and that are applicable in Express search results.
						This does not necessarily include all Item Specifics that are defined for 
						the product in the catalog. Typically, it returns only the top attributes
						(as determined by Express). See ExternalProductID for the ISBN or UPC, if applicable.
						Only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExpressSellingPreferenceCodeType.xsd #####

-->
	<xs:simpleType name="ExpressSellingPreferenceCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies the kinds of eligible listings tht the seller prefers to include on Express.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="All">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller wants all of their eligible listings to appear on Express 
						(in addition to the main eBay site), regardless of the listing format.
						Only applicable to sellers who are eligible for Express US or Express Germany.
						(By default, eBay sets this option for every eligible seller.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExpressOnly">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller only wants their Express format listings 
						to appear on Express. 
						(They don't want their fixed-price and Store Inventory format listings 
						to appear on Express.)
						Only applicable to sellers who are eligible for Express Germany.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OptOut">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller does not want any of their eligible listings to appear on Express.
						That is, the seller prefers to completely opt out of Express.
						Only applicable to sellers who are eligible for Express US.
						(Germany sellers can't use the API to opt out of Express.
						Germany sellers should see the Express Web site online help for information on how
						to end their Express qualification.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExtendedProductFinderIDType.xsd #####

-->
	<xs:complexType name="ExtendedProductFinderIDType">
		<xs:sequence>
			<xs:element name="ProductFinderID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            A product finder ID. GetCategory2CS always (and only) returns this 
            when Category.ProductFinderIDs is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderBuySide" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (out) If true, the product finder can be used as input to GetSearchResults
            to search for listings with Item Specifics on the eBay site.
            If false or not present, the product finder can be used as input to 
            GetProductSearchResults to search for catalog data (Pre-filled Item Information) 
            that a seller might want to include in a listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
							<Context>MappedCategoryArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExternalAlertIDArrayType.xsd #####

-->
	<xs:complexType name="ExternalAlertIDArrayType">
		<xs:sequence>
			<xs:element name="ExternalAlertID" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExternalProductCodeList.xsd #####

-->
	<xs:simpleType name="ExternalProductCodeType">
		<xs:annotation>
			<xs:documentation>
				As input, only applicable for AddItem, VerifyAddItem, and
				GetSearchResults requests that include the ExternalProductID property.
				Indicates the type of ID being used to identify a stock product. Used
				when listing or searching for an item with Pre-filled Item Information
				in certain categories. Certain values are also returned from
				GetSellerPayments for Half.com listings only. See the Developer's Guide
				for applicable categories.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ISBN">
				<xs:annotation>
					<xs:documentation>
						(in/out) ExternalProductID.Value contains an ISBN value.
						In listing calls, required when you pass an ISBN as the external product ID.
						(This value is also applicable to Half.com listings.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSearchResultsExpress</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPC">
				<xs:annotation>
					<xs:documentation>
						(in/out) ExternalProductID.Value contains a UPC value.
						For AddItem and VerifyAddItem, required when you pass a UPC as the external product ID.
						(This value is also applicable to Half.com listings.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSearchResultsExpress</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProductID">
				<xs:annotation>
					<xs:documentation>
						(in) ExternalProductID.Value contains an eBay catalog product ID.
						For AddItem and VerifyAddItem, required when you pass an eBay product ID
						as the external product ID.
						Not applicable with GetSearchResults or GetSearchResultsExpress.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EAN">
				<xs:annotation>
					<xs:documentation>
						(in) ExternalProductID.Value contains an EAN value.
						For AddItem and VerifyAddItem, required when you pass an EAN as the external product ID.
						Not applicable with GetSearchResults or GetSearchResultsExpress.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Keywords">
				<xs:annotation>
					<xs:documentation>
						(in) ExternalProductID.Value contains a set of keywords that uniquely identify the product.
						Only applicable to event ticket listings.
						See the eBay Web Services guide for information about using ticket keywords as an external product ID.
						For AddItem and VerifyAddItem, required when you pass a set of keywords as the external product ID.
						Not applicable with GetSearchResults or GetSearchResultsExpress.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ExternalProductIDType.xsd #####

-->
	<xs:complexType name="ExternalProductIDType">
		<xs:annotation>
			<xs:documentation>
				Contains an ISBN value, EAN value, UPC value, ticket keywords, or eBay
				catalog product ID, plus other meta-data. For event tickets, this type
				can contain a set of keywords that uniquely identify the product. Only
				applicable for certain categories that support Pre-filled Item
				Information. For items listed to eBay.com, either ExternalProductID or
				Item.ProductListingDetails can be specified in listing use cases
				(AddItem or GetItemRecommendations), but do not specify both in the same
				requst. Either ExternalProductID or ProductID can be specified in a
				GetSearchResults request, but not both. See the Developer's Guide for
				information on the categories that support usage of this field in
				listing and searching use cases. Not applicable when revising and
				relisting items. For Half.com listing use cases, contains an ISBN, UPC,
				or EAN value plus other meta-data.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Value" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						An industry-standard value that uniquely identifies the product. The
						valid values are dictated by the Type property. For convenience in AddItem, 
						you can pass an eBay product ID as input (not limited to media categories). 
						If the primary and secondary categories are both catalog-enabled, the value must apply to the
						primary category. Event tickets listings support a set of keywords
						that uniquely identify the listing. The ticket keywords specify the
						event name (the title shown on the ticket), venue name, and event
						date and time. See the eBay Web Services guide for more information
						and validation rules.
						Max length 10 for ISBN, 13 for EAN, 12 for UPC, and 4000 for
						ProductID. No max length for ticket keywords (passing too much data
						results in "no match found" errors).&lt;br&gt;
						&lt;br&gt;
						Only ISBN and UPC values can be passed in GetSearchResults. 
						For AddItem and GetSearchResults, required if Type is specified.&lt;br&gt;
						&lt;br&gt;
						Required for Half.com listing use cases, and this can only be an
						ISBN, UPC, or EAN value.
						&lt;br&gt;
						&lt;br&gt;
						GetSearchResultsExpress returns this value in ProductArray.Product.ExternalProductID.Value.
						To pass an external product ID in the request, use ExternalProductIDValue.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>See description</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<!-- N/A to ReviseItem and RelistItem -->
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReturnSearchResultOnDuplicates" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applicable for listing use cases only (not buy-side searching).
						Indicates what eBay should do if more than one product matches
						the value passed in Value. Only takes effect when more than one
						match is found. If true, the response should include an error
						and all matching product IDs. If false, the response should include
						an error but should not return the matching product IDs.
						This field is also applicable when listing Half.com items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<!-- N/A to ReviseItem and RelistItem -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Type" type="ns:ExternalProductCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The kind of identifier being passed in. The choices are listed
						in the ExternalProductCodeType code list.
						For AddItem and GetSearchResults, required if Value is specified.
						For Half.com listing use cases, only ISBN, UPC, and EAN are supported.&lt;br&gt;
						&lt;br&gt;
						GetSearchResultsExpress returns this value in ProductArray.Product.ExternalProductID.Type.
						To pass an external product ID in the request, use ExternalProductIDType.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<!-- N/A to ReviseItem and RelistItem -->
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ExternalTransactionType.xsd #####

-->
	<xs:complexType name="ExternalTransactionType">
		<xs:annotation>
			<xs:documentation>
				Container for external transaction information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ExternalTransactionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique payment transaction ID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalTransactionTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date on which transaction occurs in PayPal.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeeOrCreditAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentOrRefundAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If positive, the amount the buyer pays
						the seller through PayPal on the purchase of items. If
						negative, the amount refunded the buyer. Default = 0.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeatureDefinitionsType.xsd #####

-->
	<xs:complexType name="FeatureDefinitionsType">
		<xs:annotation>
			<xs:documentation>
				A container node for definitions of the features specified in FeatureID in the
				GetCategoryFeatures request. If no feature ID was specified, all definitions are
				returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingDurations" type="ns:ListingDurationDefinitionsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies one or more sets of listing durations. Each set gives durations for
						listing types a category could allow. If present, the corresponding feature ID
						was passed in the request or all features were requested (i.e., no feature IDs
						were specified). Use the data provided in SiteDefaults and Category to
						determine which listing formats support each listing duration and whether any
						categories override the standard settings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTermsRequired" type="ns:ShippingTermRequiredDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferEnabled" type="ns:BestOfferEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DutchBINEnabled" type="ns:DutchBINEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserConsentRequired" type="ns:UserConsentRequiredDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HomePageFeaturedEnabled" type="ns:HomePageFeaturedEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Some categories allow you to enhance a listing by putting it into a rotation
						for display on a special area of the eBay home page. Item or feedback
						restrictions may apply.&lt;br&gt;&lt;br&gt; If present, the corresponding
						feature ID was passed in the request or all features were requested (i.e., no
						feature IDs were specified). Currently, this field contains no other special
						meta-data. (An empty element is returned.) Use the data provided in
						SiteDefaults and Category to determine which categories (if any) support this
						feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProPackEnabled" type="ns:ProPackEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Defines the ProPack feature (a feature pack).
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BasicUpgradePackEnabled" type="ns:BasicUpgradePackEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Defines the BasicUpgradePack bundle feature (a feature pack).
						Applicable to Australia site (site ID 15, abbreviation AU) only.
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ValuePackEnabled" type="ns:ValuePackEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Defines the ValuePack bundle feature (a feature pack).
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProPackPlusEnabled" type="ns:ProPackPlusEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Defines the ProPackPlus bundle feature (a feature pack).
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AdFormatEnabled" type="ns:AdFormatEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DigitalDeliveryEnabled" type="ns:DigitalDeliveryEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						eBay enables you to list and sell digital files (such as Adobe PDF files) or
						information that buyers can access online or have delivered electronically. If
						a category supports digital listings, it means that you have the option to
						list digital items in that category (i.e., Item.DigitalDeliveryDetails can be
						specified in your listing request). It does not mean the category requires you
						to list items digitally. Digital listings are not eligible for eBay
						Express.&lt;br&gt;&lt;br&gt; If present, the corresponding feature ID was
						passed in the request or all features were requested (i.e., no feature IDs
						were specified). Currently, this field contains no other special meta-data.
						(An empty element is returned.) Use the data provided in SiteDefaults and
						Category to determine which categories (if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferCounterEnabled" type="ns:BestOfferCounterEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferAutoDeclineEnabled" type="ns:BestOfferAutoDeclineEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketSpecialitySubscription" type="ns:LocalMarketSpecialitySubscriptionDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketRegularSubscription" type="ns:LocalMarketRegularSubscriptionDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketPremiumSubscription" type="ns:LocalMarketPremiumSubscriptionDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketNonSubscription" type="ns:LocalMarketNonSubscriptionDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						(if any) support this feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressEnabled" type="ns:ExpressEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For the US and Germany sites, an eBay item must meet a number of eligibility
						requirements in order to also be included on eBay Express. One requirement is
						that the category needs to support Express. For example, categories that are
						not covered by PayPal Buyer Protection (e.g., Live Auctions and Motors
						vehicles) are excluded from Express.&lt;br&gt;&lt;br&gt; If present, the
						corresponding feature ID was passed in the request or all features were
						requested (i.e., no feature IDs were specified). Currently, this field
						contains no other special meta-data. (An empty element is returned.) Use the
						data provided in SiteDefaults and Category to determine which categories are
						enabled for Express.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressPicturesRequired" type="ns:ExpressPicturesRequiredDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For the US and Germany sites, an eBay item must meet a number of eligibility
						requirements in order to also be included on eBay Express. One requirement is
						that the item must include a picture (or gallery image). Some categories
						(e.g., Event Tickets) may waive this requirement if a picture is not normally
						expected.&lt;br&gt;&lt;br&gt; If present, the corresponding feature ID was
						passed in the request or all features were requested (i.e., no feature IDs
						were specified). Currently, this field contains no other special meta-data.
						(An empty element is returned.) Use the data provided in SiteDefaults and
						Category to determine which categories requires an item to include a picture
						in order to be eligible for Express.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressConditionRequired" type="ns:ExpressConditionRequiredDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For the US and Germany sites, an eBay item must meet a number of eligibility
						requirements in order to also be included on eBay Express. One requirement is
						that the item must include the Item Condition attribute (using Item
						Specifics). Some categories may waive this requirement.&lt;br&gt;&lt;br&gt; If
						present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Currently, this
						field contains no other special meta-data. (An empty element is returned.) Use
						the data provided in SiteDefaults and Category to determine which categories
						require an item to include the Item Condition attribute in order to be
						eligible for Express.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumReservePrice" type="ns:MinimumReservePriceDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If present, the corresponding feature ID was passed in the request or all
						features were requested (i.e., no feature IDs were specified). Beginning in
						mid- to late June, 2006, on the Germany, Austria, Belgium French, and Belgium
						Dutch sites, Minimum Reserve Price is supported for the Art and Antiques,
						Watches and Jewelry, and Motorbikes categories.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionConfirmationRequestEnabled" type="ns:TCREnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applies to the US eBay Motors site (except Parts and Accessories category).
						Defines the Transaction Confirmation Request feature. If the field is
						present, the corresponding feature applies to the category. The field is
						returned as an empty element (i.e., a boolean value is not returned).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerContactDetailsEnabled" type="ns:SellerContactDetailsEnabledDefinitionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeatureIDCodeList.xsd #####

-->
	<xs:simpleType name="FeatureIDCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies the feature IDs for which you want information. If you do not specify a value,
			it defaults to all feature IDs.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ListingDurations">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about the durations of listings you can use in a given category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestOfferEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports best offers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DutchBINEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Returned if a site and category allow Buy It Now for Dutch auctions.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingTermsRequired">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a seller is required to specify a shipping
						service and associated cost in order to list the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UserConsentRequired">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a bidder must consent to the bid 
						by confirming that he or she read and agrees to the terms in eBay&apos;s privacy policy.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HomePageFeaturedEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Indicates whether or not it is possible to enhance a listing by putting 
						it into a rotation for display on a special area of the eBay home page. 
						Support for this feature varies by site. Item or feedback restrictions may apply.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AdFormatEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Indicates whether the category supports ad-format
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DigitalDeliveryEnabled"/>
			<xs:enumeration value="BestOfferCounterEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports counter offers for best
						offers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestOfferAutoDeclineEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports auto decline for best
						offers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPack">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about ProPackBundle (a feature pack). Applies only to US and Canadian eBay motor vehicle sellers. Contains the Bold, Border, Featured and Highlight features.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicUpgradePack">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about the BasicUpgradePack bundle (a feature pack),
						 which combines the features Gallery and Subtitle for a discounted price. 
						 Australia site (site ID 15, abbreviation AU) only. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ValuePack">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about the ValuePack bundle (a feature pack),
						 which combines the features Gallery, Subtitle, and Listing Designer for a discounted price. Support for this feature varies by site and category. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackPlus">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about the ProPackPlus bundle (a feature pack),
						which combines the features BoldTitle, Border, Highlight, Featured, and Gallery for a discounted price. Support for this feature varies by site and category. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketSpecialitySubscription">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports local market speciality subscription.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketRegularSubscription">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports local market regular subscription.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketPremiumSubscription">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports local market premium subscription.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalMarketNonSubscription">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports local market non subscription.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExpressEnabled">
				<xs:annotation>
					<xs:documentation>
					(in) Returns information about whether a category is eligible for eBay express
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExpressPicturesRequired">
				<xs:annotation>
					<xs:documentation>
					(in) Returns information about whether a category requires pictures to be listed on express.
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExpressConditionRequired">
				<xs:annotation>
					<xs:documentation>
					(in) Returns information about whether a category requires item condition to be listed on express.
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerContactDetailsEnabled">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MinimumReservePrice">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports Minimum Reserve Price.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TransactionConfirmationRequestEnabled">
				<xs:annotation>
					<xs:documentation>
						(in) Returns information about whether a category supports the Transaction 
						Confirmation Request (TCR) feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/FeeType.xsd #####

-->
	<xs:complexType name="FeeType">
		<xs:annotation>
			<xs:documentation>
				Identifies the name and monetary amount of a fee that a member pays to eBay 
				(or an eBay company). These fee names and values are intended only as an aid to 
				help estimate the fees for a listing. Use GetAccount for an accurate final fee 
				breakdown. Returned in AddItemResponseType and related response types.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Name of the fee, for identification purposes.
						See the eBay Web Services guide for a list of current fee names.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>Fees Resulting from Listing an Item</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/ListingItems-Fees_Resulting_from_Listing_an_Item.html</URL>
						</SeeLink>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>VerifyAddSecondChanceItem</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Fee" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount of the fee that eBay will charge the member for the item.
						See the eBay.com Web site online help for a current fee schedule.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>eBay.com Fees</Title>
							<URL>http://pages.ebay.com/help/sell/fees.html</URL>
						</SeeLink>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>VerifyAddSecondChanceItem</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeedbackDetailArrayType.xsd #####

-->
	<xs:complexType name="FeedbackDetailArrayType">
		<xs:annotation>
			<xs:documentation> 
					Contains multiple individual feedback detail entries.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FeedbackDetail" type="ns:FeedbackDetailType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
						(out) Contains a single feedback detail entry. Output only.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetFeedback</CallName>
								<Returned>Conditionally</Returned>
								<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeedbackDetailType.xsd #####

-->
	<xs:complexType name="FeedbackDetailType">
	<xs:annotation>
		<xs:documentation>
				Detailed feedback information for a user. Conveys the score for the
				feedback, textual comment from the leaving user, and other
				information.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="CommentingUser" type="ns:UserIDType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) eBay user ID for the user who left the feedback.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CommentingUserScore" type="xs:int" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Feedback score of the user indicated in CommentingUser.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CommentText" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Text message left by user specified in CommentingUser. Used to provide a more
					in-depth description of the user's opinion of their transaction with the user
					about whom they left feedback. Returned as text in the language that the
					comment was originally left in.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>80 (125 for Taiwan)</MaxLength>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CommentTime" type="xs:dateTime" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Date and time (in GMT) that the feedback was submitted to eBay.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CommentType" type="ns:CommentTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Type of feedback. Can be Positive, Neutral, Negative, or Withdrawn (see the
					CommentTypeCodeType code list). Positive feedbacks add to the user's total
					feedback score, negative feedbacks lower the score, and neutral feedbacks do
					not affect the score (but do affect the overall picture of the user's online
					reputation).
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="FeedbackResponse" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Textual comment that the user targeted by feedback may leave in response or
					rebuttal to the feedback. (Cannot be submitted
					or edited via the API.)
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>80 (125 for Taiwan)</MaxLength>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Followup" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Explanation a user can give to a response.
					(Cannot be submitted or edited via the API.)
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>80 (125 for Taiwan)</MaxLength>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) The ID that uniquely identifies the item listing.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Role" type="ns:TradingRoleCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Indicates whether the user who was the feedback recipient was a Buyer or the
					Seller for that transaction.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ItemTitle" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Name of the listing for which feedback was provided.
					Returned as CDATA. This value is returned only if
					the site is China (site ID 223).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>55</MaxLength>
					<SiteInfo>
						<TheseSites>CN</TheseSites>
					</SiteInfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ItemPrice" type="ns:AmountType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) The final price for the item, associated with
					the currency identified by the currencyId attribute of the AmountType.
					This value is returned only if the site is China (site ID 223).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="FeedbackID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Unique identifier for the feedback entry.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="TransactionID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Unique identifier for the transaction about which
					this feedback entry was left.
					Returned for a detail level of ReturnAll (if the parent is returned).
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>10</MaxLength>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CommentReplaced" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
				 (out) Indicates whether eBay replaced the comment with a message
				 that the comment was removed.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ResponseReplaced" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
				 (out) Indicates whether eBay replaced the response with a message
				 that the response was removed.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="FollowUpReplaced" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
				 (out) Indicates whether eBay replaced the follow-up with a message
				 that the follow-up was removed.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetFeedback</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeedbackInfoType.xsd #####

-->
	<xs:complexType name="FeedbackInfoType">
		<xs:annotation>
			<xs:documentation>
				Information used to add a feedback note for a user.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CommentText" type="xs:string" minOccurs="0" >
				<xs:annotation>
					<xs:documentation>
						Textual comment that explains, clarifies, or justifies the feedback
						rating specified in CommentType. Still displayed if feedback is withdrawn.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>CompleteSale</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CommentType" type="ns:CommentTypeCodeType" minOccurs="0" >
				<xs:annotation>
					<xs:documentation>
						Rating of the feedback being left (e.g., Positive).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>CompleteSale</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TargetUser" type="ns:UserIDType" minOccurs="0" >
				<xs:annotation>
					<xs:documentation>
						Recipient user for whom the feedback is being left.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>CompleteSale</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<Returned>Conditionally</Returned>
							<Context>FeedbackLeft</Context>
							<Context>FeedbackReceived</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeedbackPeriodArrayType.xsd #####

-->
	<xs:complexType name="FeedbackPeriodArrayType">
		<xs:annotation>
			<xs:documentation> 
					Container for a set of feedback statistics. Contains zero one or
					multiple FeedbackPeriod objects. Output only, for the summary
					feedback data returned by GetFeedback.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FeedbackPeriod" type="ns:FeedbackPeriodType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Contains one feedback statistic giving length of the period being reported
						(e.g. last 7 days prior to the call), and total number of feedback entries
						(of the type given by the container, e.g. positive feedback) submitted during
						the indicated period. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeedbackPeriodType.xsd #####

-->
	<xs:complexType name="FeedbackPeriodType">
		<xs:annotation>
			<xs:documentation> 
					Contains the data for one type of feedback for one predefined time
					period. Parent FeedbackPeriodArrayType object indicates the type of
					feedback counted: positive, neutral, negative, or total. Output only,
					in the summary feedback data returned by GetFeedback.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PeriodInDays" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Indicates the time period for the feedback count. Returns a value indicating
						the number of days prior to the call for which feedbacks of the particular
						type are counted. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Count" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Count of the feedbacks received by the user for the time period prior to the
						call indicated in PeriodInDays. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeedbackRatingStarCodeList.xsd #####

-->
	<xs:simpleType name="FeedbackRatingStarCodeType">
		<xs:annotation>
			<xs:documentation>
					 FeedbackRatingStarCodeType - Type declaration to be used by other
					 schema. The color of a feedback score star visually denotes the
					 range in which the member's summary feedback score falls. The score
					 is the net positive feedback minus the net negative feedback left
					 for the member.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
								(out) No graphic displayed, feedback score 0-9.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Yellow">
				<xs:annotation>
					<xs:documentation>
								(out) Yellow Star, feedback score 10-49.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Blue">
				<xs:annotation>
					<xs:documentation>
								(out) Blue Star, feedback score 50-99.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Turquoise">
				<xs:annotation>
					<xs:documentation>
								(out) Turquoise Star, feedback score 100-499.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Purple">
				<xs:annotation>
					<xs:documentation>
								(out) Purple Star, feedback score 500-999.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Red">
				<xs:annotation>
					<xs:documentation>
								(out) Red Star, feedback score 1,000-4,999
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Green">
				<xs:annotation>
					<xs:documentation>
								(out) Green Star, feedback score 5,000-9,999.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="YellowShooting">
				<xs:annotation>
					<xs:documentation>
								(out) Yellow Shooting Star, feedback score 10,000-24,999.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TurquoiseShooting">
				<xs:annotation>
					<xs:documentation>
								(out) Turquoise Shooting Star, feedback score 25,000-49,999.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PurpleShooting">
				<xs:annotation>
					<xs:documentation>
								(out) Purple Shooting Star, feedback score 50,000-99,999.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RedShooting">
				<xs:annotation>
					<xs:documentation>
								(out) Red Shooting Star, feedback score 100,000 and above.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
								(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/FeedbackResponseCodeList.xsd #####

-->
	<xs:simpleType name="FeedbackResponseCodeType">
		<xs:annotation>
			<xs:documentation>
				Types of feedback responses.				
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Reply">
				<xs:annotation>
					<xs:documentation>
						A reply to feedback left by another user.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FollowUp">
				<xs:annotation>
					<xs:documentation>
						A follow-up to a feedback comment left for another user.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/FeedbackSummaryType.xsd #####

-->
	<xs:complexType name="FeedbackSummaryType">
		<xs:annotation>
			<xs:documentation>
          Specifies all feedback summary information (except Score). Contains
          FeedbackPeriodArrayType objects that each convey feedback counts for
          positive, negative, neutral, and total feedback counts - for various
          time periods each. Also conveys counts of bid retractions for the
          predefined time periods.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BidRetractionFeedbackPeriodArray" type="ns:FeedbackPeriodArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Bid retractions count, for multiple predefined time periods preceding the call. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NegativeFeedbackPeriodArray" type="ns:FeedbackPeriodArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Negative feedback entries count, for multiple predefined time periods preceding
            the call. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NeutralFeedbackPeriodArray" type="ns:FeedbackPeriodArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Neutral feedback entries count, for multiple predefined time periods preceding
            the call. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PositiveFeedbackPeriodArray" type="ns:FeedbackPeriodArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Positive feedback entries count, for multiple predefined time periods preceding
            the call. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalFeedbackPeriodArray" type="ns:FeedbackPeriodArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Total feedback score, for multiple predefined time periods preceding the call. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NeutralCommentCountFromSuspendedUsers" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Number of neutral comments received from suspended users. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UniqueNegativeFeedbackCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Number of unique negative comments. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UniquePositiveFeedbackCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Number of unique positive comments. Returned if no detail level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFeedback</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FeesType.xsd #####

-->
	<xs:complexType name="FeesType">
		<xs:annotation>
			<xs:documentation>
          Identifies a set of one or more fees that a member pays to eBay (or
          an eBay company). Instances of this type can hold one or more fees.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Fee" type="ns:FeeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
            Contains the data for one fee (such as name and amount).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>AddSecondChanceItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>VerifyAddSecondChanceItem</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FinanceOfferArrayType.xsd #####

-->
	<xs:complexType name="FinanceOfferArrayType">
		<xs:annotation>
			<xs:documentation>
				A set of financing offers: promotional offers that allow
				a buyer to purchase items on credit.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FinanceOffer" type="ns:FinanceOfferType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A financing offer.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetFinanceOffers</CallName>
								<Returned>Conditionally</Returned>
								<DetailLevels>ReturnAll</DetailLevels>
							</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FinanceOfferType.xsd #####

-->
	<xs:complexType name="FinanceOfferType">
		<xs:annotation>
			<xs:documentation>
				A promotional offer that allow the buyer to purchase items on credit.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FinanceOfferID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The unique ID associated with a particular financing
						offer. This value is used in other calls such as AddItem to indicate that an item has
						a particular financing offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerTerms" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Text that the buyer sees describing the details of the financing offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerTerms" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Text that the seller sees describing the details of the financing offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StartDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date on which the offer first becomes active.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastModifiedDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date the offer was last modified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The minimum amount for an item to which the offer applies.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RateFactor" type="xs:double">
				<xs:annotation>
					<xs:documentation>
						Interest charges associated with the finance offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Priority" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						The priority of the financing offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetFinanceOffers</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FlatRateInsuranceRangeCodeList.xsd #####

-->
	<xs:simpleType name="FlatRateInsuranceRangeCodeType">
		<xs:annotation>
			<xs:documentation>
				Flat Rate Insurance Ranges
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="FlatRateInsuranceRange1">
				<xs:annotation>
					<xs:documentation>
						Range from 0.01 to 9.99
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlatRateInsuranceRange2">
				<xs:annotation>
					<xs:documentation>
						Range from 10.00 to 49.99
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlatRateInsuranceRange3">
				<xs:annotation>
					<xs:documentation>
						Range from 50.00 to 99.99
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlatRateInsuranceRange4">
				<xs:annotation>
					<xs:documentation>
						Range from 100.00 to 199.99
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlatRateInsuranceRange5">
				<xs:annotation>
					<xs:documentation>
						Range from 200.00 to 299.99
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FlatRateInsuranceRange6">
				<xs:annotation>
					<xs:documentation>
						Range from 300.00 to more
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						 Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/FlatRateInsuranceRangeCostType.xsd #####

-->
	<xs:complexType name="FlatRateInsuranceRangeCostType">
		<xs:annotation>
			<xs:documentation>
				Insurance Cost for Item Price Range
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FlatRateInsuranceRange" type="ns:FlatRateInsuranceRangeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The price range for the shipment for which the insurance cost is being specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InsuranceCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The cost of insurance for the specified price range.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FlatShippingPreferencesType.xsd #####

-->
	<xs:complexType name="FlatShippingPreferencesType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AmountPerAdditionalItem" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If the user specifies ChargeAmountForEachAdditionalItem for
						FlatShippingRateOption, then this value is used to specify how much to charge
						for each additional item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeductionAmountPerAdditionalItem" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If the user specifies DeductAmountFromEachAdditionalItem for
						FlatShippingRateOption, then this value is used to specify how much to deduct
						for each additional item shipped.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FlatRateInsuranceRangeCost" type="ns:FlatRateInsuranceRangeCostType" minOccurs="0" maxOccurs="6">
				<xs:annotation>
					<xs:documentation>
						For the given range, specifies the cost of insurance. If the InsuranceOption
						is either Optional or Required, then 6 instances of this field must be
						specifies, one for each cost range.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FlatShippingRateOption" type="ns:FlatShippingRateOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies how the user wants flat-rate shipping to be calculated.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InsuranceOption" type="ns:InsuranceOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Whether the seller offers shipping insurance and, if
						so, whether the insurance is optional or required. Flat and
						calculated shipping.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/FlatShippingRateOptionCodeList.xsd #####

-->
	<xs:simpleType name="FlatShippingRateOptionCodeType">
		<xs:annotation>
			<xs:documentation>
				Flat Shipping Rate Options
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ChargeAmountForEachAdditionalItem">
				<xs:annotation>
					<xs:documentation>
						Charge highest shipping cost for the first item and 
						X amount for each 
						additional item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DeductAmountFromEachAdditionalItem">
				<xs:annotation>
					<xs:documentation>
						Charge highest shipping cost for the first item and deduct X amount from the 
						shipping cost of each additional item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShipAdditionalItemsFree">
				<xs:annotation>
					<xs:documentation>
						Charge highest shipping cost for the first item and ship each additional item free.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/GallerySortFilterCodeList.xsd #####

-->
	<xs:simpleType name="GallerySortFilterCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies how cross-promoted items with gallery images 
			should be displayed.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ShowAnyItems">
				<xs:annotation>
					<xs:documentation>
					(in/out) Show any items, in no particular order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShowItemsWithGalleryImagesFirst">
				<xs:annotation>
					<xs:documentation> 
					(in/out) Show items with gallery images first, before
					other items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShowOnlyItemsWithGalleryImages">
				<xs:annotation>
					<xs:documentation> 
					(in/out) Show only items with gallery images.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation> 
					(out) Reserved for internal or future use. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/GalleryTypeCodeList.xsd #####

-->
	<xs:simpleType name="GalleryTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				GalleryTypeCodeType - Indicates whether listing images are
				included in the search results (in both Picture Gallery and
				List Views) and, if so, which image listing enhancements apply
				to them. Items that have pictures but do not have image listing
				enhancements display a generic photo image in search results.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing image is not included in the search results
						(in either Picture Gallery or List Views), and no other
						image listing enhancements apply. Items that have pictures
						but do not have image listing enhancements display a generic
						photo image in search results.
						&lt;br&gt;&lt;br&gt;
						Mainly useful for RelistItem use cases when you want to
						remove an existing gallery setting. However, not all image
						listing enhancements can be removed on revise or relist.
						&lt;br&gt;&lt;br&gt;
						Note that specifying None is not necessarily the same as
						omitting GalleryType from a request. For example, specifying
						other item properties may cause the listing to be
						included in the search results Gallery by default if
						GalleryType is not specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Featured">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is highlighted and included at the top of
						search results.
						&lt;br&gt;&lt;br&gt;
						When "Featured" is included in an item listing, the listing
						also automatically gets the Gallery and Gallery Plus
						functionality. "Gallery" and "Plus" do not need to be
						specified separately in the listing. Passing "Featured",
						"Plus", and "Gallery" in the same request will return an
						error.
						&lt;br&gt;&lt;br&gt;
						For eBay Motors (SiteId 100), this may also feature certain items on the eBay Motors home page.
						&lt;br&gt;&lt;br&gt;
						Not applicable to eBay Stores Inventory listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Gallery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing image is included in the search results (in
						both Picture Gallery and List Views). Items that have
						pictures but do not have the Gallery feature will have a
						generic photo image shown in search results.
						&lt;br&gt;&lt;br&gt;
						Some listing enhancements (for example, "Featured" and
						"Plus") automatically include the Gallery functionality, so
						"Gallery" does not need to be specified separately in the
						listing. Passing "Featured", "Plus", and "Gallery" in the
						same request will return an error.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Plus">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing image has Gallery Plus funtionality. That
						is, listing includes a Gallery Plus icon that, when moused
						over or clicked, displays a large (400 px x 400 px) preview
						image of the item. Clicking the image
						displays the View Item page for that listing.
						&lt;br&gt;&lt;br&gt;
						Listing images that are originally smaller than 400 px x 400 px are centered in the preview frame. Images that are originally larger than 400 px x 400 px are scaled down to 400 px on their longest side (maintaining their original aspect ratio).
						&lt;br&gt;&lt;br&gt;
						Note that the Gallery Plus feature requires that the image
						be hosted with the eBay Picture Service (EPS). One EPS image
						is included at no cost with the Gallery Plus feature.
						&lt;br&gt;&lt;br&gt;
						When "Plus" is included in an item listing, the listing
						also automatically gets the Gallery functionality. "Gallery"
						does not need to be specified separately in the listing.
						Passing "Featured", "Plus", and "Gallery" in the same
						request will return an error.
						&lt;br&gt;&lt;br&gt;
						Not applicable to eBay Stores Inventory listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/GeneralPaymentMethodCodeList.xsd #####

-->
	<xs:simpleType name="GeneralPaymentMethodCodeType">
		<xs:annotation>
			<xs:documentation>
           GeneralPaymentMethodCodeType - Type declaration to be used by other
           schema. This code identifies the general types of payment means,
           e.g., used by payment service provider applications.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
                (out) Custom Code.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Echeck">
				<xs:annotation>
					<xs:documentation>
                (in/out) Electronic check.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ACH">
				<xs:annotation>
					<xs:documentation>
                (in/out) ACH.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Creditcard">
				<xs:annotation>
					<xs:documentation>
                (in/out) Credit-card.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalBalance">
				<xs:annotation>
					<xs:documentation>
                (in/out) Pay balance.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/GetAllBiddersModeCodeList.xsd #####

-->
	<xs:simpleType name="GetAllBiddersModeCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies which bidder information to return.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ViewAll">
				<xs:annotation>
					<xs:documentation>
						(in) Returns all bidders for an ended or still-active 
						listing. It may be used by any user.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EndedListing">
				<xs:annotation>
					<xs:documentation>
						(in) Returns all non-winning bidders for ended 
						listings only. It may be used only by a seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SecondChanceEligibleEndedListing">
				<xs:annotation>
					<xs:documentation>
						(in) Returns all non-winning bidders for an ended listing 
						who have not yet received a Second Chance Offer and noted 
						interest in receiving a Second Chance Offer. It may be used 
						only by a seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/GetRecommendationsRequestContainerType.xsd #####

-->
	<xs:complexType name="GetRecommendationsRequestContainerType">
		<xs:annotation>
			<xs:documentation>
				Specifies the data for a single item and configures the recommendation engines to use
				when processing the item with GetItemRecommendations.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingFlow" type="ns:ListingFlowCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The listing flow for which the seller is seeking Listing Analyzer recommendations.
						Not applicable to results from other recommendation engines
						(i.e., the Suggested Attributes engine or the Product Pricing engine).
						The default flow is AddItem.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>AddItem</Default>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Item" type="ns:ItemType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains fields that describe the item for which you are seeking recommendations. &lt;br&gt;
						&lt;br&gt;
						If the Listing Analyzer recommendation engine is run, the applicable fields are
						the same as the fields for AddItem, ReviseItem, or RelistItem
						requests, as determined by the value specified in ListingFlow.
						The item ID (Item.ItemID) is required when the ListingFlow is ReviseItem or RelistItem,
						and it is not applicable when the ListingFlow is AddItem.
						All other item fields are optional, even if listed as required for other calls.
						However, as some tips are dependent on the properties of the item, and as some properties
						have dependencies on other properties, we strongly recommend that you include all the item properties
						that will be included in the AddItem, ReviseItem, or RelistItem request.
						When the Listing Analyzer engine is run, tips will only be returned for fields that are specfied on the item.&lt;br&gt;
						&lt;br&gt;
						When the Product Pricing engine is run, pricing data will be based on the catalog product you specify.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This field will be removed in a future
						release. As of release 439, this field can still be passed in, but we
						recommend that you update your applications to use the ExternalProductID
						field defined on the item instead (i.e., Item.ExternalProductID). If you
						specify both Item.ExternalProductID and this field in the same request,
						eBay uses the value in Item.ExternalProductID and ignores the value in
						this field. Causes eBay to list the item with Pre-filled Item Information
						based on an ISBN value, UPC value, EAN value, ticket keywords, or eBay
						catalog product ID, plus  other meta-data that you specify.
						Only applicable when the value of ListingFlow is AddItem. See
						Item.ExternalProductID for more information and validation rules.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ModifiedFields" type="ns:ModifiedFieldType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Applicable when the ListingFlow is ReviseItem or RelistItem.
						Array of item properties that are being changed.
						In release 439 and later, ModifiedFields is no longer required to revise
						field values, but it is still supported for backward compatibility.
						See the Developer's Guide for rules on adding, modifying, and removing
						values when revising or relisting items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RecommendationEngine" type="ns:RecommendationEngineCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A recommendation engine to run. If no engines are specified, all available
						recommendation engines will run. Some engines require additional fields,
						such as Item.PrimaryCategory.CategoryID, to be specified.
						If the ProductPricing engine is specified but Item.ProductListingDetails is not specified,
						no Product Pricing engine results are returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Query" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						One or more keywords to search for when using the Suggested Attributes engine.
						Required when SuggestedAttributes is specified as the recommendation engine
						(including when no recommendation engines are specified). Only the listing title
						is searched. The words "and" and "or" are treated like any other word.
						Blank searches are not allowed (and result in a warning).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>350 (characters)</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CorrelationID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique key to identify the response that matches this recommendation request container.
						Use this key to distinguish between responses when multiple
						recommendation containers are specified (i.e., for batch requests).
						You define the key. To be useful, each correlation ID should be unique within
						the same call. That is, define a different correlation ID for each recommendation
						request container. (eBay does not validate the uniqueness of these IDs.)
						If specified, the same correlation ID will be returned in the corresponding
						recommendation response (or error response).
						We recommend that you use this when retrieving recommendations for multiple items at once.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeletedField" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Specifies the name of the field to remove from a listing.
						Applicable when the ListingFlow is ReviseItem or RelistItem.
						See the Developer's Guide for rules on removing values when revising or
						relisting items. DeletedField accepts the following values for removing
						fields: item.pictureDetails.pictureURL, item.pictureDetails.galleryURL,
						item.listingDesigner.themeID, item.listingDesigner.layoutID,
						item.payPalEmailAddress, item.proximitySearchDetails.postalCode,
						item.shippingDetails.paymentInstructions, and item.SKU. When the ListingFlow
						is RelistItem, the following values for DeletedField are also allowed:
						item.charity, item.secondaryCategory, and item.subTitle.
						DeletedField is case sensitive. The request can contain zero, one, or many
						instances of DeletedField.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/GetRecommendationsResponseContainerType.xsd #####

-->
	<xs:complexType name="GetRecommendationsResponseContainerType">
		<xs:annotation>
			<xs:documentation>
Returns recommended changes or opportunities for improvement 
related to listing data that was passed in a GetItemRecommendations request.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingAnalyzerRecommendations" type="ns:ListingAnalyzerRecommendationsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Contains tips returned from the Listing Analyzer recommendation engine, 
            if this engine was specified in the request (or if no engine was specified).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SIFFTASRecommendations" type="ns:SIFFTASRecommendationsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
             Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PricingRecommendations" type="ns:PricingRecommendationsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Contains pricing data returned from the Product Pricing engine, 
            if this engine was specified in the request (or if no engine was specified).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeRecommendations" type="ns:AttributeRecommendationsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains attribute suggestions returned from the Suggested Attributes engine, 
						if this engine was specified in the request.
						The results include suggested attributes and values based on the primary category 
						and a string you specify in the Query field. Suggestions may only be returned when the 
						Suggested Attributes engine is specified alone. If you request recommendations by using 
						multiple engines, suggested attribute data might not be returned. If attributes are returned 
						with multiple values, the values are returned in order of rank (i.e., the value that best meets 
						eBay's recommendation criteria is returned first). 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductRecommendations" type="ns:ProductRecommendationsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains zero or more product titles and IDs returned from the Suggested Attributes engine, 
						if this engine was specified in the request (or if no engine was specified).
						If applicable, use one of the suggested product IDs to list the item with Pre-filled Item Information. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CorrelationID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
             Unique key to distinguish between recommendations for each item. 
             Matches a correlation ID you defined in the request, if any.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/GiftServicesCodeList.xsd #####

-->
	<xs:simpleType name="GiftServicesCodeType">
		<xs:annotation>
			<xs:documentation>
				Each code identifies an optional service that the seller is offering if the buyer
				chooses to purchase the item as a gift. Not applicable for eBay Store Inventory
				listings.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="GiftExpressShipping">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller is offering to ship the item via
						an express shipping method as explained in the item description.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GiftShipToRecipient">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller is offering to ship to the gift recipient
						(instead of to the buyer) after payment clears.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GiftWrap">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller is offering to wrap the item (and optionally include a
						card) as explained in the item description.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/GranularityLevelCodeList.xsd #####

-->
	<xs:simpleType name="GranularityLevelCodeType">
		<xs:annotation>
			<xs:documentation>
Specifies a predefined subset of fields to return.
The predefined set of fields can vary for different calls.
Only applicable to certain calls (see request types that include
a GranularityLevel property). For calls that support this filter, 
see the eBay Web Services guide for a list of the output fields that are 
returned for each level.
Only one level can be specified at a time.
For GetSellerList, use DetailLevel or GranularityLevel in a given request, but not both.
For GetSellerList, if GranularityLevel is specified, DetailLevel is ignored.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Coarse">
				<xs:annotation>
					<xs:documentation>
					(in) For each record in the response, retrieves less data than Medium.
					See the eBay Web Services guide for a list of the output fields 
					that are returned when this level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Fine">
				<xs:annotation>
					<xs:documentation>
					For each record in the response, retrieves more data than Medium.
					See the eBay Web Services guide for a list of the output fields 
					that are returned when this level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Medium">
				<xs:annotation>
					<xs:documentation>
					For each record in the response, retrieves more data than 
					Coarse and less data than Fine.
					See the eBay Web Services guide for a list of the output fields 
					that are returned when this level is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/HitCounterCodeList.xsd #####

-->
	<xs:simpleType name="HitCounterCodeType">
		<xs:annotation>
			<xs:documentation>
			HitCounterCodeType - Type declaration to be used by other schema.
			Indicates whether a hit counter is used for the item's listing page
			and, if so, what type.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NoHitCounter">
				<xs:annotation>
					<xs:documentation>
						(in/out) No hit counter. The number of page views will not be available.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HonestyStyle">
				<xs:annotation>
					<xs:documentation>
						(in/out) A basic style hit counter (US only). Non-US sites will return errors if they use HonestyStyle as input, and should use BasicStyle instead.
					</xs:documentation>
					<xs:appinfo>
						<SiteInfo>
							<TheseSites>US</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GreenLED">
				<xs:annotation>
					<xs:documentation>
						(in/out) A green LED, computer-style hit counter (US only). Non-US sites will return errors if they use GreenLED as input, and should use RetroStyle instead.
					</xs:documentation>
					<xs:appinfo>
						<SiteInfo>
							<TheseSites>US</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Hidden">
				<xs:annotation>
					<xs:documentation>
						(in/out) A hidden hit counter (US only). The number of page views will only be available to
						the item's seller. For faster "View Item" page loads, use HiddenStyle.
					</xs:documentation>
					<xs:appinfo>
						<SiteInfo>
							<TheseSites>US</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicStyle">
				<xs:annotation>
					<xs:documentation>
							(in/out) A basic style hit counter.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RetroStyle">
				<xs:annotation>
					<xs:documentation>
						 (in/out) A retro, computer-style hit counter.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HiddenStyle">
				<xs:annotation>
					<xs:documentation>
						(in/out) A hidden hit counter. The number of page views will only be available to
						the item's seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
							(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/HomePageFeaturedEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="HomePageFeaturedEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines whether Home Page Featured is available on the site.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/InsuranceOptionCodeList.xsd #####

-->
	<xs:simpleType name="InsuranceOptionCodeType">
		<xs:annotation>
			<xs:documentation>
				The seller's requirements regarding whether the buyer pays
				for shipping insurance.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Optional">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller offers the buyer the choice of paying
						for shipping insurance or not.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Required">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller requires that the buyer pay for
						shipping insurance.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotOffered">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller does not offer shipping insurance to the buyer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IncludedInShippingHandling">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller is not charging separately for shipping
						insurance costs; any insurance is already included in the
						base shipping cost.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotOfferedOnSite">
				<xs:annotation>
					<xs:documentation>
            (in/out) Shipping insurance is not offered as a separate option on the site
						where the item is listed. (Some shipping services, such as
						DE_InsuredExpressOrCourier, include insurance as part of the service.) If
						another insurance option is specified in the listing request and the site does
						not support shipping insurance as a separate option, eBay will reset the
						insurance option to this value. At the time of this writing, this option is
						only meaningful for the eBay Germany, Austria, and Switzerland sites.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/InsuranceSelectedCodeList.xsd #####

-->
	<xs:simpleType name="InsuranceSelectedCodeType">
		<xs:annotation>
			<xs:documentation>
				The insurance selected by the buyer.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NotOffered">
				<xs:annotation>
					<xs:documentation>
						Shipping insurance was not offered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OfferedNotSelected">
				<xs:annotation>
					<xs:documentation>
						Shipping insurance was offered but not selected.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OfferedSelected">
				<xs:annotation>
					<xs:documentation>
						Shipping insurance was offered and selected.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Required">
				<xs:annotation>
					<xs:documentation>
						Shipping insurance was required.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IncludedInShippingHandling">
				<xs:annotation>
					<xs:documentation>
						Shipping insurance was included in Shipping and Handling fee.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/InternationalShippingServiceOptionsType.xsd #####

-->
	<xs:complexType name="InternationalShippingServiceOptionsType">
		<xs:annotation>
			<xs:documentation>
        Shipping costs and options related to an international shipping service. When used
				as input, if one is provided, at least one domestic ShippingService must be
				provided. This type does not exist before compatibility level 383.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ShippingService" type="xs:token" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) An international shipping service offered for shipping the item (for
						example, UPS Ground). For a list of valid values that you can cache for future
						use, call GeteBayDetails with DetailName set to ShippingServiceDetails. For
						flat and calculated shipping.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The meaning of this element depends on the call and on whether flat
						or calculated shipping has been selected. (For example, it could be the cost
						to ship a single item, the cost to ship all items, or the cost to ship just
						the first of many items, with ShippingServiceAdditionalCost accounting for the
						rest.) When returned by GetItemShipping, it includes the packaging and
						handling cost. For flat and calculated shipping.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddOrder</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<SeeLink>
							<Title>Getting Shipping Cost Information</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceAdditionalCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cost of shipping each additional item beyond the first
						item. Should be zero for single-item listings. Default value is
						0.00. For flat shipping only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddOrder</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServicePriority" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller-preferred presentation order relative to other
						service options. Valid values are: 1, 2 and 3 (first, second
						and third choices). For flat and calculated shipping.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddOrder</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShipToLocation" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						An international location or region to which the item may be
						shipped via this particular shipping service. Associated with
						the shipping service by the seller. Use GeteBayDetails to
						determine which locations are valid per site. These values
						are string equivalents of values found in
						ShippingRegionCodeType and CountryCodeType. For the AddItem family
						of calls, this field is required if any international shipping service
						has been specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddOrder</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemArrayType.xsd #####

-->
	<xs:complexType name="ItemArrayType">
		<xs:annotation>
			<xs:documentation>
			Container for a list of items. Can contain zero, one, or multiple
			ItemType objects, each of which conveys the data for one item listing.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Item" type="ns:ItemType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					Contains the data properties that define one item listing.
					GetSellerEvents and GetSellerList only return items if any are available for the seller
					within the time window specified in the request.&lt;br&gt;
					&lt;br&gt;
					Some optional fields are only returned if the seller defined them for the item.
					Some fields are only returned under particular conditions specified in the individual
					field descriptions. For example, a buyer's contact information might only be returned 
					if the member who is making the request (as identified in eBayAuthToken) has a 
					transactional relationship with that buyer. &lt;br&gt;
					&lt;br&gt;
					For calls that support detail levels, the set of fields 
					returned is also controlled by the value of DetailLevel in the request.
					For some calls, other parameters in the request can also control the data returned for each item.
					For example, GranularityLevel controls the fields to return for each item in the GetSellerList response.
					&lt;br&gt;
					&lt;br&gt;
					For GetSearchResultsExpress, ItemDetails controls the fields to return for each item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
							<!-- Using separate CallInfo due to detail levels. -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemFormatSortFilterCodeList.xsd #####

-->
	<xs:simpleType name="ItemFormatSortFilterCodeType">
		<xs:annotation>
			<xs:documentation>
			  Specifies that you want to display items based
			  on selling format, such as Buy It Now or Store items.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ShowAnyItems">
				<xs:annotation>
					<xs:documentation>
					(in/out) Show any items, in no particular order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShowItemsWithBINFirst">
				<xs:annotation>
					<xs:documentation> 
					(in/out) Show items with a Buy It Now price first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShowOnlyItemsWithBIN">
				<xs:annotation>
					<xs:documentation> 
					(in/out) Show only items with a Buy It Now price.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShowOnlyStoreItems">
				<xs:annotation>
					<xs:documentation> 
					(in/out) Show only store inventory items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation> 
					(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ItemIDType.xsd #####

-->
	<xs:simpleType name="ItemIDType">
		<xs:annotation>
			<xs:documentation>
				Type that represents the unique identifier for a single
				item listing.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ItemListCustomizationType.xsd #####

-->
	<xs:complexType name="ItemListCustomizationType">
		<xs:annotation>
			<xs:documentation>
				Defines how a list of items should be returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Include" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns the list using the default settings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingType" type="ns:ListingTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the listing type of items in the returned list.
						Valid for ActiveList.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>ActiveList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Sort" type="ns:ItemSortTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies how the items returned should be sorted.
						Valid for WatchList, BidList, WonList, LostList,
						ScheduledList, ActiveList, UnsoldList, and GetItemsAwaitingFeedback.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DurationInDays" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the time period during which an item was
						won or lost. Similar to the Period drop-down menu
						in the My eBay user interface. Valid for WonList, LostList, SoldList,
						UnsoldList, BuyingReminders, and SellingReminders. 
					</xs:documentation>
					<xs:appinfo>
						<Min>0</Min>
						<Max>60</Max>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IncludeNotes" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether to include Item.PrivateNotes and Item.eBayNotes
						in the response. Valid for WatchList, BidList, WonList, LostList,
						ScheduledList, ActiveList, SoldList, and UnsoldList.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies how to create virtual pages in the returned list.
						Valid for BidList, WonList, LostList, ScheduledList, ActiveList, SoldList, UnsoldList,
						and GetItemsAwaitingFeedback. Default for EntriesPerPage with GetMyeBayBuying is 200.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemLocationCodeList.xsd #####

-->
	<xs:simpleType name="ItemLocationCodeType">
		<xs:annotation>
			<xs:documentation>
           ItemLocationCodeType - Type declaration to be used by other schema.
           Use with Country Code argument in GetSearchResults.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ItemAvailableIn">
				<xs:annotation>
					<xs:documentation>
                Items available to the specified country.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemLocatedIn">
				<xs:annotation>
					<xs:documentation> 
                Items located in the specified country.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ItemSortFilterCodeList.xsd #####

-->
	<xs:simpleType name="ItemSortFilterCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies how items should be sorted.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="EndingLast">
				<xs:annotation>
					<xs:documentation>
					(in/out) Sort items by ending time, with items ending last first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EndingSoonest">
				<xs:annotation>
					<xs:documentation>
					(in/out) Sort items by ending time, with items ending soonest first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HighestPrice">
				<xs:annotation>
					<xs:documentation>
					(in/out) Sort items by price, with the highest price first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LowestPrice">
				<xs:annotation>
					<xs:documentation> 
					(in/out) Sort items by price, with the lowest price first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NewlyListed">
				<xs:annotation>
					<xs:documentation>
					(in/out) Sort items by listing time, with newly listed items first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RandomlySelected">
				<xs:annotation>
					<xs:documentation>
					(in/out) Sort items in a randomly selected order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation> 
					(out) Reserved for internal or future use. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ItemSortTypeCodeList.xsd #####

-->
	<xs:simpleType name="ItemSortTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				(in) Indicates the field and direction (ascending or
				descending) by which to sort a returned list of items.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ItemID">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by Item ID (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Price">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by price (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StartPrice">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by start price (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Title">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by item title (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BidCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by number of bids on the item (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Quantity">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by quantity (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StartTime">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by listing start time (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EndTime">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by listing end time (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerUserID">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the seller's user ID, in alphabetical order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TimeLeft">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the time left for the item's listing,
						in ascending order: active items, good-til-cancelled items,
						and completed items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ListingDuration">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by listing duration (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ListingType">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by listing type (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CurrentPrice">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by current price (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReservePrice">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by reserve price (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MaxBid">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by maximum bid price (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BidderCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by number of bidders (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HighBidderUserID">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the user ID of the highest bidder (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>LostList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerUserID">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the user ID of the buyer (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerPostalCode">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the buyer's postal code (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerEmail">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the buyer's email address, in alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerEmail">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the seller's email address, in alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TotalPrice">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by total price (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WatchCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the number of items being watched (ascending). The WatchCount of an item is the number of watches that buyers have placed on an item using their eBay accounts.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestOfferCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the number of best offers (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuestionCount">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the number of questions (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingServiceCost">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the cost indicated for shipping (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BestOfferList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeedbackReceived">
				<xs:annotation>
					<xs:documentation>
							(in) Sort by type of feedback received, positive, negative, or neutral.
							In ascending order - negative, neutral, positive.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeedbackLeft">
				<xs:annotation>
					<xs:documentation>
							(in) Sort by type of feedback received, positive, negative, or neutral.
							In ascending order - negative, neutral, positive.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UserID">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by user ID, in alphabetical order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuantitySold">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the number of items sold (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestOffer">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuantityAvailable">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the number of items available (ascending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuantityPurchased">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the number of items purchased (ascending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WonPlatform">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the platform on which the item was won (eBay items last).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SoldPlatform">
				<xs:annotation>
					<xs:documentation>
					(in) Sort by the platform on which the item was sold (eBay items last).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>SoldList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ListingDurationDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the duration of the listing (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ListingTypeDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the listing type (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CurrentPriceDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the current price of the listed item (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReservePriceDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the listing's reserve price (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MaxBidDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the highest bid on the item (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BidderCountDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by number of bidders (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HighBidderUserIDDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the user ID of the highest bidder (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerUserIDDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the user ID of the buyer, in reserve
					alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerPostalCodeDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the buyer's postal code, in descending
						order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerEmailDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the buyer's email address, in
						reverse alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerEmailDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the seller's email address,
						in reverse alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TotalPriceDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the total price of the order, (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WatchCountDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by watch count (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuestionCountDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by number of questions (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingServiceCostDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the cost of shipping (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeedbackReceivedDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by type of feedback received, positive, negative, or neutral.
						In descending order - positive, neutral, negative.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeedbackLeftDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by type of feedback received, positive, negative, or neutral.
						In descending order - positive, neutral, negative.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UserIDDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by user ID, in descending order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuantitySoldDescending"/>
			<xs:enumeration value="BestOfferCountDescending"/>
			<xs:enumeration value="QuantityAvailableDescending"/>
			<xs:enumeration value="QuantityPurchasedDescending"/>
			<xs:enumeration value="BestOfferDescending"/>
			<xs:enumeration value="ItemIDDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by Item ID (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PriceDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by price (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StartPriceDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by start price (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TitleDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by item title (descending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BidCountDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by number of bids on the item (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="QuantityDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the quantity of items sold (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StartTimeDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by listing start time (descending).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EndTimeDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by listing end time (descending).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerUserIDDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by seller user ID, in reverse alphabetical order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TimeLeftDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by time left on the listing, in descending
						order: completed items, good-til-cancelled items,
						and active items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WonPlatformDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the platform on which the item was won (ebay Express items last).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SoldPlatformDescending">
				<xs:annotation>
					<xs:documentation>
						(in) Sort by the platform on which the item was sold (ebay Express items last).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>SoldList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ItemTotalsType.xsd #####

-->
	<xs:complexType name="ItemTotalsType">
	<xs:annotation>
		<xs:documentation>
			Details about items involved in the summary for the specified time period.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="TotalQuantity" type="xs:long" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Number of items involved in the summary.
				</xs:documentation>
			</xs:annotation>
		</xs:element>
		<xs:element name="TotalValue" type="ns:AmountType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Total value associated with the items in this summary.
				</xs:documentation>
			</xs:annotation>
		</xs:element>
	</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemTransactionIDArrayType.xsd #####

-->
	<xs:complexType name="ItemTransactionIDArrayType">
		<xs:annotation>
			<xs:documentation>
				Container of ItemTransactionIDs.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemTransactionID" type="ns:ItemTransactionIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						An ItemID-TransactionID container.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemTransactionIDType.xsd #####

-->
	<xs:complexType name="ItemTransactionIDType">
		<xs:annotation>
			<xs:documentation>
				A container for item and transaction IDs.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The ID of an item.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The ID of a transaction.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemType.xsd #####

-->
	<xs:complexType name="ItemType">
		<xs:annotation>
			<xs:documentation>
				Contains the data defining one item. A seller populates an object of
				this type at listing time with the definition of a new item. A seller
				also uses an object of this type to re-list or revise an item. Calls
				that retrieve item data (such as the GetSellerList call) return an object of
				this type, filled with the item's data. Some fields are applicable both
				to eBay listings and Half.com listings. Some fields are only applicable to eBay listings,
				and others are only applicable to Half.com listings.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ApplicationData" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns custom, application-specific data associated with the item.
						The data you specify is stored by eBay with the item for your own reference,
						but it is not used by eBay in any way. Use ApplicationData to store
						special information for yourself, such as a part number.
						For a SKU in an eBay.com listing, use the SKU element instead.
						ApplicationData is not applicable to Half.com. For Half.com listings,
						use SellerInventoryID instead.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>32</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSetArray" type="ns:AttributeSetArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Item Specifics (such as new or used condition) to include in a listing.
						Carries one or more instances of AttributeSet in a list. For Item Specifics in
						general, an item will be associated with no more than two full attribute sets
						(one for the primary category and one for the secondary category). For some
						international sites, an item can specify additional site-wide attribute sets.
						Some categories (such as Event Tickets and US Real Estate) require Item
						Specifics. See "Working with Attribute-Based Features" in the eBay Web
						Services Guide for information on working with Item Specifics. Use
						GetCategory2CS and GetAttributesCS to determine when attributes are required
						for a category. Also see "Specifying an Item's Condition".&lt;br&gt;&lt;br&gt;
						For a listing to be eligible for eBay Express, the item condition is required
						in most cases. Some categories are exempt from this requirement. See "eBay
						Express" in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						When you revise a listing, if the listing has bids and ends within 12 hours,
						you cannot change or add attributes. If the listing has bids but ends in more
						than 12 hours, you cannot change existing attribute data, but you can add
						attributes that were not previously specified. To delete all attributes when
						you revise or relist, specify Item.AttributeSetArray in DeletedField and don't
						pass AttributeSetArray in the request.&lt;br&gt;&lt;br&gt; For
						AddLiveAuctionItem and ReviseLiveAuctionItem, specify a maximum of one
						AttributeSet for Item Specifics that are associated with SecondaryCategory (a
						US eBay site category), plus any number of additional AttributeSet properties
						for site-wide attributes that are applicable to the US eBay
						site.&lt;br&gt;&lt;br&gt; For GetCategoryListings, AttributeSetArray can
						return the item condition (not other Item Specifics) for eBay
						Germany.&lt;br&gt;&lt;br&gt; GetSearchResults can return Item Specifics when
						the request either specifies IncludeCondition as true or specifies a product
						finder search, and a detail level of ItemReturnAttributes or ReturnAll. If
						IncludeCondition was true, AttributeSetArray may return the item condition
						(e.g., New). If SearchRequest was used to perform a product finder search, the
						list of attributes is limited to Item Specifics that would be included in the
						summary search results on the Web site, if any. For example, event ticket
						listings may return the venue name, section, and row. In some categories, no
						summary attributes are returned in search results (even when the item is
						listed with Item Specifics.) &lt;br&gt;&lt;br&gt; In GetItemRecommendations,
						if you use the Suggested Attributes engine, the engine interprets attributes
						you pass in as attributes that do NOT need recommendations (i.e., attributes
						that the seller has already filled in as desired). The engine only returns
						recommendations for attributes that you do not specify, and only for
						attributes associated with the primary category.&lt;br&gt;&lt;br&gt; Not
						applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeArray" type="ns:AttributeArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Used to specify the item condition. Only applicable to Half.com (not eBay listings).
						You can revise this property for Half.com listings.
						This does not use the same Attributes format as eBay's Item Specifics.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseItem</CallName>
							<!-- Half.com does not support RelistItem. -->
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LookupAttributeArray" type="ns:LookupAttributeArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Use this as a shortcut for specifying the Item Condition attribute by name
						instead of by ID. Only valid when using AddItem for items in Media categories
						(Books, DVD and Movies, Music, and Video Game categories). You can pass either
						AttributeSetArray or LookupAttributeArray, but you cannot pass both in the
						same request. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ApplyShippingDiscount" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Multiple Item Shipping Discount. Seller specifies as input when listing,
						re-listing, or revising an item to indicate whether a shipping discount is to
						be applied when the buyer pays for the item in the checkout process and the
						item's transaction is combined with other transactions into an order. Returned
						with retrieved item data, indicating a shipping discount is applicable.&lt;br&gt;
						&lt;br&gt;
						Not returned by GetItem (see Item.ShippingDetails.ApplyShippingDiscount instead).&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<!-- N/A to GetItem -->
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AutoPay" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, the seller requests immediate payment for the item. If false or not
						specified, immediate payment is not requested. (In responses, does not
						indicate whether the item is actually still a candidate for purchase via
						immediate payment.) Only applicable for items listed on PayPal-enabled sites
						in categories that support immediate payment (see AutoPayEnabled in
						GetCategories), when seller has a Premier or Business PayPal account (see
						PayPalAccountType in Getuser). If true, the seller must also accept PayPal as
						a payment method for the item (see Item.PaymentMethods). Required for
						digitally delivered goods (see Item.DigitalDeliveryDetails). See the eBay Web
						Services guide section on Immediate Payment for additional requirements and
						dependencies. Also see the section on working with the eBay Motors site for
						additional rules. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<Default>false</Default>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentDetails" type="ns:PaymentDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains data associated with eBay Motors payments (Durations for deposit and
						full payments). Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BiddingDetails" type="ns:BiddingDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MotorsGermanySearchable" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Listing upgrade that features the item in eBay search results on the mobile.de
						partner site. If true in listing requests and responses, the seller is
						purchasing or has purchased cross-promotional placement on the mobile.de site.
						See the eBay Web Services Guide for applicable categories, revise and relist
						rules, and additional information on featuring vehicles on the Mobile.de Site.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerProtection" type="ns:BuyerProtectionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the status of the item's eligibility for the PayPal Buyer Protection
						program. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyItNowPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For Chinese auction listings, Buy It Now allows a user to purchase the item at
						a fixed price and end the auction immediately. eBay China also supports Buy It
						Now for Dutch auction listings (see International Differences Overview in the
						eBay Web Services guide). Use this field to add Buy It Now and specify the
						amount a buyer would need to bid to take advantage of the Buy It Now feature.
						&lt;br&gt;&lt;br&gt;
						On the main eBay site, not applicable to fixed-price items
						(ListingTypeCodeType type StoresFixedPrice or FixedPriceItem), AdFormat
						listings, or Half.com listings. For fixed-price and Half.com listings, see
						StartPrice instead. See the eBay Web Services Guide for validation rules when
						revising US eBay Motors listings, including rules for lowering the Buy It Now
						price of a Motors listing.&lt;br&gt;&lt;br&gt; On most sites, once a Chinese
						auction has bids, the listing is no longer eligible for Buy It Now. However,
						calls like GetItem and GetSearchResults still return the BuyItNowPrice that
						the seller set for the listing. You can use Item.SellingStatus.BidCount to
						determine whether an auction with Buy It Now has bids or not. With
						GetSearchResults, you can examine the Item.SearchDetails.BuyItNowEnabled flag
						to determine whether an auction is still a Buy It Now listing. With GetItem,
						you can examine the Item.ListingDetails.BuyItNowAvailable flag to determine
						whether a Dutch auction is still a Buy It Now listing.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>16</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetBestOffers</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryMappingAllowed" type="xs:boolean" default="false" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Controls how eBay handles cases in which an ID specified in PrimaryCategory
						and/or SecondaryCategory no longer exists in the current category structure:
						If you pass a value of true in CategoryMappingAllowed, eBay will look up the
						current ID that is mapped to the same category and use the new ID for the
						listing (if any). The new ID will be returned in the response as CategoryID
						(for the primary category) or Category2ID (for the secondary category). If
						CategoryMappingAllowed is not set or contains a value of "false" (the
						default), an error will be returned if a selected category ID no longer
						exists. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Charity" type="ns:CharityType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Identifies a Giving Works listing and the benefiting nonprofit charity
						organization selected by the charity seller, if any. If specified, the seller must
						also accept PayPal as a payment method for the item (see Item.PaymentMethods).
						Giving Works listings are not eligible for eBay Express. Not applicable to
						Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<!-- N/A to ReviseItem -->
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Country" type="ns:CountryCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Two-letter ISO 3166 country code. In some calls, used with the Location field
						to indicate the city and country where the item is located. Also applicable as
						input to AddItem and related calls when you list items to Half.com (specify
						US).
						&lt;br&gt;
						&lt;br&gt;
						In GetSearchResultsExpress, only returned when ItemDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CrossPromotion" type="ns:CrossPromotionsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for cross-promoted items related to a specific item ID.
						The items are either upsell or cross-sell, according to the promotion
						method passed in the request.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Currency associated with the item's price information. 3-letter ISO 4217
						currency code that corresponds to the site specified in the item-listing
						request. Also applicable as input to AddItem and related calls when you list
						items to Half.com (specify USD). You cannot modify a listing's currency when
						you revise or relist an item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Description of the item. In listing requests, you can submit your description
						using CDATA if you want to use HTML or XML-reserved characters in the
						description. An error is returned if this contains malicious JavaScript
						content. (For related eBay policy, see
						http://pages.ebay.com/help/policies/listing-javascript.html.)
						&lt;br&gt;&lt;br&gt;
						The Description field is required for all listings, except certain listings
						that include Pre-filled Item Information. (See "About the Pre- filled Item
						Information API." in the eBay Web Services Guide.) Even if your application
						does not support listings items with Pre-filled Item Information, you should
						be aware that this also means GetItem, GetSellerList, and GetBidderList may
						return some items with empty Description fields.
						&lt;br&gt;&lt;br&gt;
						If you embed pictures in the description (by using IMG tags) instead of using
						PictureURL, but you want a camera icon to appear in search and listing pages,
						specify the following null-image URL in PictureURL:
						http://pics.ebay.com/aw/pics/dot_clear.gif. See "Including Pictures in an Item
						Listing" in the eBay Web Services Guide.
						&lt;br&gt;&lt;br&gt;
						For eBay Live Auctions listings, JavaScript is not allowed.
						&lt;br&gt;&lt;br&gt;
						Not applicable to Half.com. (For Half.com, use AttributeArray.Attribute with
						attributeLabel="Notes" to specify a brief description or note to the buyer.)
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>500000 (some sites may allow more, but the exact number may vary)</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Distance" type="ns:DistanceType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The distance used in a proximity search distance calculation.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FinanceOfferID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies a promotional offer that allow the buyer to purchase items on
						credit. You can call GetFinanceOffers to retrieve the current set of valid
						offers that can be specified for items. If specified, the seller must also
						accept PayPal as a payment method for the item (see Item.PaymentMethods). Not
						applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GiftIcon" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If set, a generic gift icon displays next the listing's title in search and
						browse pages. GiftIcon must be set to be able to use GiftServices options.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GiftServices" type="ns:GiftServicesCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Optional gift services that the seller is offering if the buyer chooses to
						purchase the item as a gift. Only returned if offered by the seller.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HitCounter" type="ns:HitCounterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether an optional hit counter is displayed on the item's listing
						page and, if so, what type. See HitCounterCodeType for specific values.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The ID that uniquely identifies the item listing. The ID is generated
						by eBay after an item is listed. You cannot choose or revise this
						value.&lt;br&gt;
						&lt;br&gt;
						Also applicable to Half.com. For Half.com, you can specify either ItemID or
						SellerInventoryID in a ReviseItem request to uniquely identify the
						listing.&lt;br&gt;
						&lt;br&gt;
						In GetItemRecommendations, the item ID is required when the value of
						ListingFlow is ReviseItem or RelistItem, but it is not applicable when the
						value of ListingFlow is AddItem.
						&lt;br&gt;
						&lt;br&gt;
						In GetSearchResultsExpress, always returned when ItemArray.Item is returned.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19. (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits.)</MaxLength>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<CallName>GetBestOffers</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>SecondChanceOffer</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>Transaction</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingDetails" type="ns:ListingDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Various details about a listing, some of which are calculated or derived after
						the item is listed. These include the start and end time, converted
						(localized) prices, and certain flags that indicate whether the seller
						specified fields whose values are not visible to the requesting user.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>SecondChanceOffer</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>Transaction</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingDesigner" type="ns:ListingDesignerType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains the detail data for the Listing Designer theme and template (if either
						are used), which can optionally be used to enhance the appearance of the
						description area of an item's description. See ListingDesignerType for its
						child elements.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingDuration" type="xs:token" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Describes the number of days the seller wants the listing to be active
						(available for bidding/buying). The valid choice of values depends on the
						listing type. The duration specifies the seller's initial intent at listing
						time. If the listing ends early, the value of the listing duration does not
						change. The end time for an auction is calculated by adding the duration to
						the item's start time. When a listing's duration is changed, any related fees
						(e.g., 10-day fee) may be debited or credited (as applicable). When you revise
						a listing, the duration cannot be reduced if it will result in ending the
						listing within 24 hours of the current date-time. You can change the value of
						this field only if the listing has no bids (or no items have sold) and the
						listing does not end within 12 hours. For a list of valid values that you can
						cache for future use, call GetCategoryFeatures with DetailLevel set to
						ReturnAll and look for ListingDuration results.
						Also required to Half.com (but only specify GTC).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ScheduledList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingEnhancement" type="ns:ListingEnhancementsCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Describes listing upgrades that sellers can select for a fee, such as the
						BoldTitle upgrade. Also includes feature packs for saving on listing upgrades.
						See &lt;a href="http://pages.ebay.com/help/sell/ia/promoting_your_item.html"&gt;Listing Upgrades&lt;/a&gt;
						in the eBay Web site online help. You cannot remove listing upgrades when you
						revise a listing. &lt;br&gt;
						&lt;br&gt;
						For AddLiveAuctionItem and ReviseLiveAuctionItem, you can specify a maximum of
						10 featured lot items per live auction catalog.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingType" type="ns:ListingTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the format of the listing the seller wants to use, such as
						Chinese auction or fixed price. See Different Ways of Selling in the eBay online help:
						http://pages.ebay.com/help/sell/ia/formats.html
						Also see Listing Types in the eBay Web Services guide.
						You cannot modify the listing type of an active listing.&lt;br&gt;
						&lt;br&gt;
						Optional for eBay.com listings (defaults to Chinese). Required for Half.com
						listings (and the value must be Half). Required for Express format listings on
						Express Germany (and the value must be Express). Eligible items listed in the
						fixed price or Store Inventory format on the US or Germany site are also
						included on eBay Express. See "eBay Express" in the eBay Web Services guide
						for more information about listing on Express.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<!-- N/A to ReviseItem -->
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>Transaction</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingSubtype" type="ns:ListingSubtypeEnum" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Location" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the geographical location of the item (along with Country). When you
						revise a listing, you can add or change this value only if the listing has no
						bids (or no items have sold) and it does not end within 12 hours. Also
						applicable as input to AddItem and related calls when you list items to
						Half.com.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>45</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LotSize" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A lot is a set of two or more similar items that must be purchased together in
						a single transaction. A listing can have multiple lots (instead of multiple
						items). When LotSize is specified, the listing price reflects the price of
						each lot (not each item within the lot). In this case, Quantity indicates the
						number of lots being listed, and LotSize indicates the number of items in each
						lot. (If a listing has no lots, Quantity indicates the number of separate
						items being listed.) Important: Lot items can be listed only in lot-enabled
						categories. GetCategories returns LSD (lot size disabled) with a value of true
						for categories that do not support lots.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NowAndNew" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true in listing requests and responses, the item is listed with Now and
						New. Only applicable to Buy It Now, fixed-price, and Store Inventory listings
						on certain eBay sites. See the eBay Web Services guide for details. In
						requests that list items, only valid if the seller also specifies the item
						condition (as new), predefined return policy attributes, a buy it now or fixed
						price, and shipping costs. To remove Now and New from a listing, set the value
						to false. If the listing has bids (or items have been sold) or the listing
						ends within 12 hours, you cannot add or remove NowAndNew when you revise the
						listing.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PartnerCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not currently operational.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PartnerName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not currently operational.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentMethods" type="ns:BuyerPaymentMethodCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Identifies the payment method (such as credit card or PayPal) the seller will
						accept for the buyer to pay for the purchase of the item. &lt;br&gt;&lt;br&gt;
						If you specify multiple PaymentMethods fields, the repeating fields must be
						contiguous. For example, you can specify PayPalEmailAddress after a list of
						repeating PaymentMethods fields, but not between them:&lt;br&gt;
						&lt;br&gt;
						&amp;lt;PaymentMethods&amp;gt;AmEx&amp;lt;/PaymentMethods&amp;gt;&lt;br&gt;
						&amp;lt;PaymentMethods&amp;gt;PersonalCheck&amp;lt;/PaymentMethods&amp;gt;&lt;br&gt;
						&amp;lt;PaymentMethods&amp;gt;PayPal&amp;lt;/PaymentMethods&amp;gt;&lt;br&gt;
						&amp;lt;PayPalEmailAddress&amp;gt;mypaypalemail@ebay.com&amp;lt;/PayPalEmailAddress&amp;gt;&lt;br&gt;&lt;br&gt;
						In general, if you separate repeating instances of a field, the results will
						be unpredictable. This rule applies to all repeating fields
						(maxOccurs="unbounded" or greater than 1) in the schema. See "Overview of the
						Schema" in the eBay Web Services guide.&lt;br&gt;
						&lt;br&gt;
						A listing must have at least one valid payment method. When you revise or
						relist an item and you specify a payment method that is invalid for the target
						site, eBay ignores the invalid payment method, applies the other valid
						changes, and returns a warning to indicate that the invalid payment method was
						ignored. If multiple payment methods were invalid, the warning indicates that
						they were all ignored. If you modify the listing so that it includes no valid
						payment methods, an error is returned. This situation could occur when the
						seller removes all valid payment methods or when all the payment methods
						specified for the item are no longer valid on the target site.&lt;br&gt;
						&lt;br&gt;
						For a listing to be eligible for Express US, PayPal is a required payment
						method. For Express Germany, Express format listings must include PayPal, but
						fixed-price and Store Inventory listings do not require PayPal (as long as a
						default PayPal account is specified in the seller's Express preferences). See
						eBay Express information in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						Payment methods are not applicable to eBay Real Estate ad format listings or Half.com.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>Listing an Item</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ListingAnItem</URL>
						</SeeLink>
						<SeeLink>
							<Title>(SetUserPreferences) SellerPaymentPreferences</Title>
							<URL>io_SetUserPreferences.html#Request.SellerPaymentPreferences</URL>
						</SeeLink>
						<SeeLink>
							<Title>Accept PayPal as a Payment Method</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressPaymentMethods</URL>
						</SeeLink>
						<SeeLink>
							<Title>Overview of the XML API Schema</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=SchemaOverview</URL>
						</SeeLink>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalEmailAddress" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Valid PayPal email address for the PayPal account that the seller will use if
						they offer PayPal as a payment method for the listing. eBay uses this to
						identify the correct PayPal account when the buyer pays via PayPal during the
						checkout process. (As a seller can have more than one PayPal account, you
						cannot necessarily rely on PayPal account data returned from GetUser for
						details about the account associated with the PayPal email address that the
						seller specifies.)&lt;br&gt;
						&lt;br&gt;
						Required if seller has chosen PayPal as a payment method (PaymentMethods) for
						the listing.&lt;br&gt;
						&lt;br&gt;
						For a listing to be eligible for Express US, the seller needs to use an email
						address that is in good standing and that is associated with a PayPal Premier
						or PayPal business account that is set to ship to unconfirmed addresses. For
						Express Germany, PayPalEmailAddress must be specified for Express format
						listings, but it is optional for fixed-price and Store Inventory listings (as
						long as an eligible default PayPal account is specified in the seller's
						Express preferences). If the specified PayPal account becomes ineligible for
						eBay Express payments (because the seller blocked unconfirmed addresses or
						some other change occurred), the items associated with that account may become
						ineligible for Express and may no longer appear on Express.
						See eBay Express information in the eBay Web Services Guide for more
						information.&lt;br&gt;
						&lt;br&gt;
						For digital listings, the seller needs to use an email address that is
						associated with a PayPal Premier or PayPal business account. &lt;br&gt;
						&lt;br&gt;
						To remove this value when you revise or relist an item, use DeletedField. When
						you revise a listing, if the listing has bids (or items have been sold) or it
						ends within 12 hours, you can add PayPalEmailAddress, but you cannot remove
						it.&lt;br&gt;
						&lt;br&gt;
						Not applicable to eBay Motors listings. Also not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>Listing an Item</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ListingAnItem</URL>
						</SeeLink>
						<SeeLink>
							<Title>Accept PayPal as a Payment Method</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressPaymentMethods</URL>
						</SeeLink>
						<SeeLink>
							<Title>(SetUserPreferences) SellerPaymentPreferences</Title>
							<URL>io_SetUserPreferences.html#Request.SellerPaymentPreferences</URL>
						</SeeLink>
						<SeeLink>
							<Title>(SetUserPreferences) ExpressPreferences.DefaultPayPalAccount</Title>
							<URL>io_SetUserPreferences.html#Request.ExpressPreferences.DefaultPayPalAccount</URL>
						</SeeLink>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrimaryCategory" type="ns:CategoryType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Category ID for the first (or only) category in which the item is listed (or
						is to be listed in the case of new, as-yet unlisted items). Use calls like
						GetCategories and GetCategoryFeatures to determine valid values for the site
						on which you are listing (see the eBay Web Services Guide for information on
						working with categories). Also see Item.CategoryMappingAllowed and
						Item.CategoryBasedAttributesPrefill.&lt;br&gt;
						&lt;br&gt;
						Most eBay.com categories are also eligible for eBay Express. Categories not
						covered by PayPal Buyer Protection are excluded. Also, certain categories that
						do not support item condition may be excluded. See "eBay Express" in the eBay
						Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						When revising a listing, you can change the primary category only if an item
						has no bids (or no items have sold) and the listing does not end within 12
						hours. If you change the listing category, any Item Specifics (attributes)
						that were previously specified may be dropped from the listing if they aren't
						valid for the new category. In that case, if you still want to include Item
						Specifics, you need to specify attributes that are appropriate for the
						category. See Item.AttributeSetArray.&lt;br&gt;
						&lt;br&gt;
						You cannot change the meta-categories for vehicles (i.e., you cannot change a
						truck to a motorcycle), but you can change the leaf category (e.g., change one
						motorcycle subcategory to another motorcycle subcategory). See the eBay Web
						Services Guide for additional rules. International sites (such as the eBay
						Germany site) have similar rules for revising vehicle categories. &lt;br&gt;
						&lt;br&gt;
						For eBay Live Auctions (e.g., in AddLiveAuctionItem), this is the eBay Live
						Auctions site category in which to list the item. This can be different from
						the category that is associated with the seller's catalog. See Specifying eBay
						Live Auctions Categories in the eBay Web Services guide.&lt;br&gt;
						&lt;br&gt;
						For GetItemRecommendations, use this to control the category that will be
						searched for recommendations. Specify the category in which the item will be
						listed. See the eBay Web Services guide for differences in validation rules
						depending on whether you are using the Listing Analyzer engine, Product
						Pricing engine, or Suggested Attributes engine.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>Categories</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=CategoryOverview</URL>
						</SeeLink>
						<SeeLink>
							<Title>Specifying eBay Live Auctions Categories</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=LiveAuctionCategories</URL>
						</SeeLink>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrivateListing" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, designates the listing as a private auction. The list of bidders on
						private auctions is hidden when the active listing is viewed. Sellers may want
						to use this option when they believe that potential bidders for a listing
						would not want their User IDs disclosed to others. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductListingDetails" type="ns:ProductListingDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies stock product information to include in a listing. Only applicable
						when listing items with Pre-filled Item Information. If the item's primary and
						secondary category are both catalog-enabled, the product listing details must
						be applicable to the primary category. If only one category is catalog-
						enabled, the product listing details must be applicable to the catalog-enabled
						category. Either Item.ExternalProductID or Item.ProductListingDetails can be
						specified in an AddItem request, but not both. See the eBay Web Services Guide
						for information on listing with Pre-filled Item Information.
						&lt;br&gt;&lt;br&gt; If a listing includes Pre-filled Item Information and you
						change a category, the rules for continuing to include Pre-filled Item
						Information depend on whether or not the new category is mapped to a
						characteristic set associated with the same product ID. When you revise a
						listing, if it has bids or it ends within 12 hours, you cannot change the
						product ID and you cannot remove existing product data. However, you can
						change or add preferences such as IncludeStockPhotoURL,
						UseStockPhotoURLAsGallery, and IncludePrefilledItemInformation. To delete all
						catalog data when you revise or relist an item, specify
						Item.ProductListingDetails in DeletedField and don't pass
						ProductListingDetails in the request.&lt;br&gt;&lt;br&gt; For
						GetItemRecommendations, see the eBay Web Services guide for differences in
						validation rules when using the Product Pricing engine.&lt;br&gt;&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProximitySearchDetails" type="ns:ProximitySearchDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Proximity search information for the item. This response type is deprecated
						and may be removed from the schema in a future release. Remove application
						dependencies on this type. For item location, refer to Item.PostalCode
						instead.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Quantity" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For AddItem and related calls, this is the number of items in the listing. For
						new listings being defined, this is the initial number of items the seller
						offers for sale. Even during a Dutch auction, where one of several items can
						be purchased during the auction, this number does not change. Sellers need to
						meet certain feedback requirements to specify a quantity greater than 1.
						&lt;br&gt;&lt;br&gt;
						When you revise a listing, you can add or change this value only if the
						listing has no bids (or no items have sold) and it does not end within 12
						hours. For auction items, a change in the auction's quantity could result in a
						change in the auction type. For example, if the quantity is changed from 1 (a
						Chinese auction) to 2, the auction is now a Dutch auction. This may impose new
						requirements and fees on the seller. &lt;br&gt;&lt;br&gt; For GetSellerEvents
						calls, Quantity is returned only for listings where item quantity is greater
						than 1. Also applicable to Half.com (valid range 1 to 1000).
						You can revise this field for Half.com listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrivateNotes" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not supported as input in listing calls. Use SetUserNotes
						instead&lt;br&gt;
						&lt;br&gt;
						A note a user makes on an item in their My eBay account.
						The note is prefaced with the words My Note.
						For eBay.com, only GetMyeBayBuying and GetMyeBaySelling (not GetItem)
						return this field, and only if you pass IncludeNotes in the request.
						Only visible to the user who created the note.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com (instead, use
						Item.AttributeArray.Attribute.Value.ValueLiteral for Half.com notes.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>ReviseItem</CallName>
							<TagStatus>Obsolete</TagStatus>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RegionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This field is used by the China site only. On all other sites, the use of
						regions for locating items has been replaced by distance-based searching
						and searches by location name. For sites that no longer support the use of
						regions, use Item.PostalCode and Item.Location instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RelistLink" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applicable only to re-listing an item. If true, creates a link in the item's
						old listing for the item that points to the new relist page, which
						accommodates users who might still look for the item under its old item ID.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReservePrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The lowest price at which the seller is willing to sell the item. (StartPrice
						must be lower than ReservePrice.) Not all categories support reserve prices.
						See GetCategories and "Determining Whether a Category Supports Reserve Prices"
						in the eBay Web Services guide. In calls that retrieve item data, ReservePrice
						only has a non-zero value for listings with a reserve price and where the user
						requesting the item data is also the item's seller. Not applicable to fixed-
						price items or ad format listings. For more information on reserve price
						auctions, see
						http://pages.ebay.com/help/sell/reserve.html. &lt;br&gt;&lt;br&gt;
						You can remove the reserve price of a US eBay Motors listing if the category
						allows it, the current reserve price has not been met, and the reserve price
						is at least $2.00 more than the current high bid. In this case, if the item
						has bids, the reserve price is set to $1.00 over the current high bid. The
						next bid meets the reserve and wins.
						See the Fees Overview on the eBay Web site (http://pages.ebay.com/help/sell/fees.html)
						for information about fee credits that may be available when the reserve price
						is removed for a Motors listing. See the eBay Web Services guide for
						validation rules when revising US Motors listings.&lt;br&gt;&lt;br&gt;
						For AddLiveAuctionItem and ReviseLiveAuctionItem, the seller needs to make
						sure they specify the amount in the currency selected for the live auction
						event. When you revise a Live Auction item, you can lower an existing reserve
						price, but you cannot add a reserve price or remove an existing reserve price
						if the item has absentee bids or ends in less than 12
						hours.&lt;br&gt;&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>16</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>SoldList</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReviseStatus" type="ns:ReviseStatusType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether an item has been revised since the listing became
						active and, if so, which among a subset of properties have been changed
						by the revision.
						Output only.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ScheduleTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Allows a user to schedule a listing to start at the specified time in the
						future. Specify the time (in GMT) that the item's listing is scheduled to be
						active on eBay. Input only. For ReviseItem, you can modify this value if the
						current schedule time is in the future. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SecondaryCategory" type="ns:CategoryType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID for second category in which the item is listed (also see
						Item.PrimaryCategory). Listing an item in a second category is optional. Also
						see Item.CategoryMappingAllowed and Item.CategoryBasedAttributesPrefill. Not
						applicable to eBay China (site 223). Not applicable to Half.com. &lt;br&gt;
						&lt;br&gt;
						Most eBay.com categories are also eligible for eBay Express. Categories not
						covered by PayPal Buyer Protection are excluded. Also, certain categories that
						do not support item condition may be excluded. See "eBay Express" in the eBay
						Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						When revising a listing, you can add, remove, or change the secondary category
						only if the listing has no bids (or no items have sold) and it does not end
						within 12 hours. If you change the secondary category, any corresponding Item
						Specifics (attributes) that were previously specified may be dropped from the
						listing if they aren't valid for the category. In that case, if you still want
						to include Item Specifics, you need to specify attributes that are valid for
						the category. See Item.AttributeSetArray.&lt;br&gt;
						&lt;br&gt;
						You cannot list US eBay Motors vehicles in two categories. However, you can
						list Parts &amp; Accessories in two categories. Furthermore, as of June 2006,
						you can list the same item in an eBay Motors Parts &amp; Accessories category
						and in an eligible eBay category, as long as the primary category is
						associated with the site on which you are listing. That is, the two categories
						can be a mix of Motors Parts &amp; Accessories and eBay site categories. (Real
						Estate, Mature Audience (adult), and Business &amp; Industrial categories are
						not eligible for listing in two categories in this manner.) For example, if
						you list on Motors, the primary category could be 6750 (eBay Motors &gt; Parts
						&amp; Accessories &gt; Apparel &amp; Merchandise &gt; Motorcycle &gt; Jackets
						&amp; Leathers), and the secondary category could be 57988 (eBay &gt;
						Clothing, Shoes &gt; Accessories &gt; Men's Clothing &gt; Outerwear), If you
						list on the main eBay site, the primary category could be 57988 and the
						secondary category could be 6750. When you revise an item, you can change the
						secondary category from a Motors Parts &amp; Accessories category to an eBay
						category or vice versa if the listing has no bids (or no items have sold) and
						it does not end within 12 hours. The Final Value Fee is based on the primary
						category in which the item is listed.&lt;br&gt;
						&lt;br&gt;
						For eBay Live Auctions (e.g., AddLiveAuctionItem), this is the eBay US site
						category in which to list the item. (This can be any eBay US category except
						Motors or Real Estate categories.) Note that eBay Live Auctions does not
						charge a fee to specify an eBay category (i.e., no List in Two Category fees).
						See Specifying eBay Live Auctions Categories in the eBay Web Services guide.
						In AddLiveAuctionItem, you need to specify SecondaryCategory if you are
						including Item Specifics (AttributeSetArray). For eBay Live Auctions, you can
						add SecondaryCategory when you revise the lot item, but you cannot change or
						remove an existing secondary category if the item has absentee bids or it ends
						in less than 12 hours.&lt;br&gt;
						&lt;br&gt;
						For GetItemRecommendataions, use this to control the category that will be
						searched for recommendations. Specify the category in which the item will be
						listed. See the eBay Web Services guide for differences in validation rules
						depending on whether you are using the Listing Analyzer engine, Product
						Pricing engine, or Suggested Attributes engine.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FreeAddedCategory" type="ns:CategoryType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID for a second category that eBay added as a free promotion. You cannot add this yourself.
						Only returned if the item was listed in a single category and eBay added a free second category.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteHostedPicture" type="ns:SiteHostedPictureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Deprecated in the response with compatibility level 439 and higher.
						PictureDetails returned instead. Applications should remove dependencies on
						SiteHostedPicture: SiteHostedPicture contains the data for pictures associated
						with an item, when those pictures are hosted on the eBay site (eBay Picture
						Services). The similar element, VendorHostedPicture, contains the data for
						pictures hosted somewhere other than on the eBay site. Both SiteHostedPicture
						and VendorHostedPicture are being phased out and may be removed in a future
						release. Applications should use PictureDetails instead. If SiteHostedPicture
						or VendorHostedPicture are passed in with PictureDetails, PictureDetails will
						take precedence.&lt;br&gt;&lt;br&gt;
						For a listing to be eligible for eBay Express, it must include a picture,
						gallery, or stock photo URL. Some categories are exempt from this requirement.
						See "eBay Express" in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<TagStatus>Deprecated</TagStatus>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Seller" type="ns:UserType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for information about this listing's seller.
						Not applicable to Half.com.
						&lt;br&gt;
						&lt;br&gt;
						In GetSearchResultsExpress, only returned when ItemDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellingStatus" type="ns:SellingStatusType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Various details about the current status of the listing, such as the current
						number of bids and the current high bidder. Not applicable to
						Half.com.&lt;br&gt;
						&lt;br&gt;
						For GetSearchResultsExpress, this is always returned when ItemArray.Item is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>SoldList</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingOption" type="ns:ShippingOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates where the seller is willing to ship the item. Default is SiteOnly.
						See ShippingOptionCodeType for specific values. If SitePlusRegions is
						selected, when the item is listed, then at least one region must also be
						specified (in ShippingRegions). Obsolete with compatibility level 383 and
						higher. Use Item.ShipToLocations instead.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Obsolete</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingDetails" type="ns:ShippingDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The shipping-related details for an item or transaction, including flat and
						calculated shipping costs and shipping insurance costs.&lt;br&gt;
						&lt;br&gt;
						For a listing to be eligible for eBay Express, shipping details are required
						to support the eBay Express shopping cart. For flat shipping, this means the
						shipping service and cost are required. For calculated shipping, all of the
						usual parameters (weight, originating postal code, etc.) are required. See
						"eBay Express" in the eBay Web Services Guide. In GetSearchResultsExpress,
						always returned when ItemArray.Item is returned.
						&lt;br&gt;
						&lt;br&gt;
						Shipping details are not applicable to Real Estate listings and Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ScheduledList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingRegions" type="ns:ShippingRegionCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Indicates the global regions to which the seller is willing to ship the
						item(s). Only applicable if the seller specifies SitePlusRegions for the
						shipping option (ShippingOptionCodeType). See ShippingRegionCodeType for
						specific shipping regions values. Obsolete with compatibility level 373 and
						higher. Use Item.ShipToLocations instead.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Obsolete</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTerms" type="ns:ShippingTermsCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates who pays the shipping costs for the item(s), the buyer or the seller.
						Deprecated with compatibility level less than 309 and obsolete with
						compatibility level 309 or higher.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<TagStatus>Obsolete</TagStatus>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShipToLocations" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						An international location or region to which the seller is willing to ship,
						regardless of shipping service. The country of the listing site is added by
						eBay. Use GeteBayDetails with a DetailName of ShippingLocationDetails to
						determine which international locations are valid for the site. Omit
						ShipToLocations if you want to ship only within the country of the listing
						site. To state that you do not wish to ship at all, set ShipToLocations to
						None. ReviseItem can add a ShipToLocation.
						Applicable with compatibility level 373 and higher.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>length of longest name in ShippingRegionCodeType and CountryCodeType</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>ShipToLocation: Two Types, Two Meanings</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShipToLocation</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Site" type="ns:SiteCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of the site on which the item is listed. The listing site affects the
						business logic and validation rules that are applied to the request, which in
						turn affect the values that are returned in the response, as well as values
						that appear on the eBay Web site. For example, the listing site can affect the
						validation of Category in listing requests, international business seller
						requirements, the values of converted (localized) prices in responses, the
						item-related time stamps that are displayed on the eBay Web site, the
						visibility of the item in some types of searches (e.g., GetCategoryListings),
						and other information. In some cases (such as with listings on eBay Express),
						the rules are determined by a combination of the site, the user's registration
						address, and other information. You cannot change the site when you revise a
						listing.&lt;br&gt;
						&lt;br&gt;
						When you specify Item.Site in AddItem, it must be consistent with the numeric
						site ID that you specify in the request URL (for the SOAP API) or the X-EBAY-
						API-SITEID header (for the XML API).
						Not applicable to Half.com.
						For eBay Live Auctions, pass a value of US.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<!-- N/A to ReviseItem -->
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>SecondChanceOffer</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StartPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The original price of the item at listing or re-listing time. If this
						value changes when the item is revised, the new value becomes the original
						price.
						&lt;br&gt;&lt;br&gt;
						For auction-type listings, competitive bidding starts at this value. Once at
						least one bid has been placed, StartPrice remains the same but CurrentPrice is
						incremented to the amount of each succeeding bid. If ReservePrice is also
						specified, the value of StartPrice must be lower than the value of
						ReservePrice.
						&lt;br&gt;&lt;br&gt;
						For fixed-price listings (FixedPriceItem), Store Inventory (StoresFixedPrice)
						listings, and Express format listings, this is the constant price at which a
						buyer may purchase the item.
						&lt;br&gt;&lt;br&gt;
						For a listing to be eligible for Express, the max start price is USD 10,000.00
						for the US and EUR 10000 for Germany. (Additional price limits may be imposed
						by the seller's PayPal account or the payment method used. Such limits cannot
						be determined via the eBay API and are not covered in eBay's API
						documentation, as they may vary for each user.)&lt;br&gt;
						&lt;br&gt;
						Also applicable to Half.com (valid range 0.75 to 9999.99). You can revise this
						field for Half.com listings.
						&lt;br&gt;
						For eBay Live Auctions items, this is the amount at which absentee Internet
						bidding for the item begins. Maximum length 16. Must be greater than zero. The
						seller needs to make sure they specify the amount in the currency selected for
						the live auction event.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>SoldList</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Storefront" type="ns:StorefrontType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains information related to the item in the context of a seller's eBay
						Store. Applicable for auction formats, Basic Fixed Price, and Store Inventory
						format items listed by eBay Stores sellers.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SubTitle" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Subtitle to use in addition to the title. Provides more keywords when buyers
						search in titles and descriptions. You cannot use HTML in the Subtitle. (HTML
						characters will be interpreted literally as plain text.) If you pass any
						value, this feature is applied (with applicable fees).&lt;br&gt;
						&lt;br&gt;
						Not applicable to listings in US eBay Motors passenger vehicle, motorcycle,
						and "other vehicle" categories or to listings in CA eBay Motors passenger
						vehicle and motorcycle categories. (Other US and CA eBay Motors categories
						support this field as of December 2005.) For eBay Motors categories that do
						not support this field, use Item Specifics (AttributeSetArray) to specify the
						vehicle subtitle.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.&lt;br&gt;
						&lt;br&gt;
						When you revise a item, you can add or change the subtitle, but you cannot
						remove it.&lt;br&gt;
						&lt;br&gt;
						In GetSearchResultsExpress, only returned when ItemDetails is set to Fine
						and a subtitle was specified for the item.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>55</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TimeLeft" type="xs:duration" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Time left before the listing ends.
						The duration is represented in the ISO 8601 duration format (PnYnMnDTnHnMnS).
						See Data Types in the eBay Web Services guide for information about this format.
						For ended listings, the time left is PT0S (zero seconds).
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Context>WatchList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						 Name of the item as it appears in the listing or the Gallery. Required for
						 most items. Optional if you list in Books, Music, Movies, or Video Games
						 categories and you use Pre-filled Item Information (as the title can be pre-
						 filled based on the catalog product title).&lt;br&gt;
						 &lt;br&gt;
						 You cannot use HTML or JavaScript in the Title. (HTML characters will be
						 interpreted literally as plain text.)&lt;br&gt;
						 &lt;br&gt;
						 For AddItem, not applicable to Half.com. For GetOrders, not returned from eBay.com,
						 but a title from the Half.com catalog is returned from Half.com instead.&lt;br&gt;
						 &lt;br&gt;
						 You can add or change the value of this tag only if an item has no bids
						 (or no items have sold) and the listing does not end for 12 hours.
						 &lt;br&gt;
						 &lt;br&gt;
						 In GetSearchResultsExpress, always returned when ItemArray.Item is returned.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>55</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>SecondChanceOffer</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>SoldList</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UUID" type="ns:UUIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						We recommend that you use InvocationID instead of Item.UUID. InvocationID
						provides more flexibility than UUID. Universally unique constraint tag. Use
						UUID to ensure that you only list a particular item once, particularly if you
						are listing many items at once. If you add an item and do not get a response,
						resend the request with the same UUID. If the item was successfully listed the
						first time, you will receive an error message for trying to use a UUID that
						you have already used. The error will also include the item ID for the
						duplicated item and a boolean value indicating whether the duplicate UUID was
						sent by the same application. The UUID can only contain digits from 0-9 and
						letters from A-F and must be 32 characters long. The UUID value must be unique
						across all categories that are children of the same meta-category (i.e.,
						within the hierarchy of each level-1 category). UUID is not applicable to
						ReviseItem (because you are modifying an existing item, not creating a new
						one.) Also applicable as input to AddItem and related calls when you list
						items to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>32</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<!-- N/A to ReviseItem -->
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VATDetails" type="ns:VATDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for eBay's Business User features. A business seller can choose to
						offer an item exclusively to bidders and buyers that also represent businesses.
						Only applicable when the item is listed in a B2B-enabled category (on a site
						that supports B2B business features).
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VendorHostedPicture" type="ns:VendorHostedPictureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Deprecated in the response with compatibility level 439 and higher.
						PictureDetails returned instead. Applications should remove dependencies on
						VendorHostedPicture: VendorHostedPicture contains the data for a picture
						associated with an item, when that picture is hosted on a site of the seller's
						choice (other than on the eBay site with eBay Picture Services). The similar
						element, SiteHostedPicture, contains the data for pictures hosted on the eBay
						site.  Both SiteHostedPicture and VendorHostedPicture are being phased out and
						may be removed in a future release. Applications should use PictureDetails
						instead. If SiteHostedPicture or VendorHostedPicture are passed in with
						PictureDetails, PictureDetails will take precedence.&lt;br&gt;&lt;br&gt;
						For a listing to be eligible for eBay Express, it must include a picture,
						gallery, or stock photo URL. Some categories are exempt from this requirement.
						See "eBay Express" in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerVacationNote" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The seller is on vacation (as determined by the seller's store preferences) in
						two cases: i.) the item is a Store Inventory item and the seller has chosen to
						hide Store Inventory items while on vacation, and ii.) the seller has chosen
						to add a message to listed items while on vacation.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WatchCount" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The number of watches placed on this item from buyers' My eBay accounts.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HitCount" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The number of page views for the item. This number is calculated by eBay and
						cannot be set via the API. Returned if the hit counter type is BasicStyle,
						RetroStyle, or HiddenStyle. For HiddenStyle, HitCount is returned only if the
						requestor is the item's seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisableBuyerRequirements" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If false (or omitted): if BuyerRequirements is present, its requirements are
						to be used; otherwise, any requirements specified in My eBay are to be used.
						If true: no requirements are considered from any source (and if
						BuyerRequirements is present, it is ignored).
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerRequirements" type="ns:BuyerRequirementsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for buyer requirements. Individual buyer requirements cannot be
						modified or added. The call needs to provide the entire set of buyer
						requirements to modify or add any. This is only returned if the caller is the
						seller. See also the eBay Web site help regarding
						&lt;a target="_blank" href="http://pages.ebay.com/help/sell/buyer-requirements.html"&gt;Selecting
						Buyer Requirements&lt;/a&gt;.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferDetails" type="ns:BestOfferDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for BestOffer properties associated with the item.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AnythingPoints" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether the seller is offering Anything Points for the item.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LiveAuctionDetails" type="ns:LiveAuctionDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Describes the live auction-specific details of a lot item.
						Applicable to eBay Live Auctions only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocationDefaulted" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						True if eBay provided a central location as a result of the user
						not specifying a location.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ThirdPartyCheckout" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether checkout for this is to be handled by a Third-Party Checkout
						application. Only for authorized Third-Party Checkout applications. See
						"Third-Party Checkout" in the main documentation.&lt;br&gt;
						&lt;br&gt;
						For a listing to be eligible to appear on eBay Express, you also need to agree
						to use a Platform Notification (or transaction calls) instead of Third-Party
						Checkout to process Express sales. To do this, specify
						ThirdPartyCheckoutIntegration with a value of true.&lt;br&gt;
						IMPORTANT: If you are not authorized to support Third Party Checkout and your
						application is not the original listing application, never specify
						ThirdPartyCheckout or ThirdPartyCheckoutIntegration in your request (even if
						you revise a listing that already includes these flags). Otherwise, the
						listing may be dropped from Express or you may get unexpected results. See
						"eBay Express" in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Third Party Checkout</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ThirdPartyCheckout</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UseTaxTable" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the seller's tax table is to be used when applying and
						calculating taxes. If true, a tax table must exist for the seller, and the
						following tags should not be used: SalesTaxState, SalesTaxPercent,
						ShippingIncludedInTax.&lt;br&gt;
						&lt;br&gt;
						If the seller wants to charge sales tax for eBay Express sales, the seller
						needs to create a tax table on eBay and use it for their listings. As eBay
						Express payments are handled via a shopping cart, you will not be able to
						calculate and add sales tax during your own checkout flow.
						&lt;br&gt;&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<SeeLink>
							<Title>eBay Express</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=eBayExpress</URL>
						</SeeLink>
						<SeeLink>
							<Title>Enabling Multi-jurisdiction Sales Tax</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=SalesTax</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GetItFast" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the seller has opted the listing into the Get
						It Fast feature. If GetItFast is true and if at least one of
						the domestic shipping services offered by the seller is an
						expedited shipping service, every shipping service offered by
						the seller is considered a Get It Fast service, and the seller
						commits to delivering the item to the buyer-selected shipping
						service within one day.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Enabling Multi-jurisdiction Sales Tax</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=SalesTax</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerResponsibleForShipping" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applicable for listings in vehicle categories on the US eBay Motors site and
						eBay Canada site. (No business effect if specified for other categories or
						sites, as the Web site will not display the information to buyers.) If true,
						the buyer is responsible for vehicle pickup or shipping. If false, specify
						vehicle shipping arrangements in the item description. Default is true. (The
						description can also include vehicle shipping arrangements when this value is
						true.) If the item has bids or ends within 12 hours, you cannot modify this
						flag. Do not specify ShippingOption or ShippingDetails.ShippingServiceOptions
						for vehicle listings.
						&lt;br&gt;&lt;br&gt;
						If true and the listing is on the US eBay Motors site, and you want the
						listing to be visible on the eBay Canada site, set Item.ShipToLocations to CA.
						If true and the listing is on the eBay Canada site , and you want your listing
						to be visible on the US eBay Motors site, set Item.ShipToLocations to US. Not
						applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LimitedWarrantyEligible" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applicable to US eBay Motors vehicle listings only. If false, the vehicle will
						not be considered for a limited warranty by eBay. If your application lists
						Motors vehicles, you must provide the seller with an opportunity to indicate
						whether the vehicle has not been modified and is not a special type (e.g.,
						Corvette ZR1). If LimitedWarrantyEligible is passed in, it means the
						application has presented the seller with checkboxes to indicate this
						information. If true, the seller has verified that the vehicle has not been
						modified and is not a special type. If false, the seller has verified that
						vehicle has been modified or it is a special type. Passing a value of true
						does not guarantee that eBay will offer a limited warranty. It only makes the
						listing eligible for consideration. See the eBay Web Services Guide for more
						information about Motors vehicle listings.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="eBayNotes" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns a note from eBay displayed below items in the user's My eBay account.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QuestionCount" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the number of questions buyers have posted about the item.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Relisted" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether or not the item is a relisted item. This value is determined by eBay
						and cannot be set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QuantityAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies how many of a certain item are available.
						Not applicable to Half.com.&lt;br&gt;
						&lt;br&gt;
						For GetSearchResultsExpress, only returned when ItemDetails is set to Fine.&lt;br&gt;
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Context>WatchList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SKU" type="ns:SKUType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This element is a SKU (stock-keeping unit) defined by a seller. The seller can
						use a SKU to identify one item or use the same SKU for multiple items.
						Preferable to ApplicationData for SKUs and inventory tracking. Different
						sellers can use the same SKUs. This element can be used by sellers to track
						complex flows of products and information. This element preserves a SKU,
						enabling a seller to obtain it before and after a transaction is created. To
						remove a SKU when you revise or relist an item, use DeletedField. Not
						applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>50</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CategoryBasedAttributesPrefill" type="xs:boolean" default="false" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Allows eBay to auto-fill some of a listing's Item Specifics (attribute) values
						based on the listing's category (or categories). Auto-filling attributes based
						on a category is not the same as using Pre-filled Item Information based on a
						catalog product (see ProductListingDetails). If true, also specify
						Item.CategoryMappingAllowed with a value of true. (Alternatively, you can
						auto-fill attributes on the client side by using mapping meta-data returned by
						GetAttributesCS.) See the eBay Web Services guide for more information.
						Ignored if the category does not support auto-filling attributes.&lt;br&gt;
						&lt;br&gt;
						If you also pass in attributes in AttributeSetArray, your values will override
						any auto-filled values for the same attributes. Once you have overridden the
						value of an auto-filled attribute for a given listing, eBay will not auto-fill
						it on subsequent ReviseItem requests (even if you remove the overridden
						value). &lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchDetails" type="ns:SearchDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for values that indicate whether a listing uses the Buy It Now feature,
						whether a listing is no more than one day old, and whether a listing has an image
						associated with it. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PostalCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Postal code of the place where the item is located. This value is used for
						proximity searches.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTermsInDescription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether details about shipping costs and
						arrangements are specified in the item description.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Causes eBay to list the item with Pre-filled Item Information based on an ISBN
						value, UPC value, EAN value, ticket keywords, or eBay catalog product ID, plus
						other meta-data that you specify. Only applicable for certain categories. See
						the eBay Web Services Guide for information on the categories that currently
						support usage of this field. If you are listing in a media category and the
						primary and secondary category are both catalog-enabled, the external ID must
						be for a product associated with the primary category. If only one category is
						catalog-enabled, this external ID must be for a product that is associated
						with the catalog-enabled category. If you are listing an event ticket, the
						external ID must be associated with the primary category.&lt;br&gt;&lt;br&gt;
						Either Item.ExternalProductID or Item.ProductListingDetails can be specified
						in an AddItem (or VerifyAddItem) request. Do not specify both.
						ExternalProductID is not applicable when revising and relisting items (use
						Item.ProductListingDetails instead). If you use Item.ExternalProductID instead
						of Item.ProductListingDetails, eBay sets IncludeStockPhotoURL and
						UseStockPhotoAsGallery to true automatically.&lt;br&gt;
						&lt;br&gt;
						The stock photo URL satisfies the eBay Express picture requirement. See "eBay
						Express" in the eBay Web Services Guide.&lt;br&gt;&lt;br&gt;
						In GetItemRecommendations, only applicable when the value of ListingFlow is
						AddItem. Not applicable when the recommendation engine is ProductPricing.
						&lt;br&gt;&lt;br&gt;
						Optional for eBay.com listings.
						Not applicable as input to AddItem for Half.com listings. (Use ExternalProductID
						at the root level of the AddItem request instead for Half.com listings.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerInventoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for a Half.com item. Must be an alphanumeric value (with no
						symbols) that is unique across the seller's active (unsold) inventory on
						Half.com. For Half.com, you can specify either ItemID or SellerInventoryID in
						a ReviseItem request to uniquely identify the listing. Only returned from
						GetOrders if the seller specified a value when the item was listed. You cannot
						revise this field. Not applicable to eBay.com listings.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>100</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>ReviseItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PictureDetails" type="ns:PictureDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains the data for a picture associated with an item. Replaces the
						deprecated SiteHostedPicture and VendorHostedPicture in the response with
						compatibility level 439 or greater. With the future deprecation of
						SiteHostedPicture and VendorHostedPicture in the input, applications should
						use PictureDetails in the input as well. If SiteHostedPicture or
						VendorHostedPicture are passed in with PictureDetails, PictureDetails will
						take precedence.&lt;br&gt;&lt;br&gt;
						For a listing to be eligible for eBay Express, it must include a picture,
						gallery, or stock photo URL. Some categories are exempt from this requirement.
						See "eBay Express" in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DigitalDeliveryDetails" type="ns:DigitalDeliveryDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates that the listing is a digitally delivered item. For listing calls,
						specifies information about the file and how it is delivered. By specifying
						the digital delivery fields, the seller agrees that they are the legal rights
						owner of this digital item or they have been authorized by the rights owner to
						sell this digital item.&lt;br&gt;
						&lt;br&gt;
						Transaction-retrieval calls like GetSellerTransactions return an
						(intentionally) empty DigitalDeliveryDetails node for digital listing
						purchases. (If the transaction is not for a digital listing, the node is not
						returned.)&lt;br&gt;
						&lt;br&gt;
						If you are listing in two categories and you specify this option, both
						categories must support digital listings. Call GetCategoryFeatures to
						determine which categories (if any) support digitally delivered goods. If a
						category supports this feature, it does not mean you are required to use this
						feature. (It only means that this feature is an option in that category.)
						&lt;br&gt;&lt;br&gt;
						If specified, the item must be sold at a fixed price (basic fixed price or
						Store Inventory), and the seller must require PayPal as the only payment
						method. The seller also needs to use a verified PayPal Premier or Business
						acount. On some sites, the seller must require Immediate Payment (see
						Item.AutoPay) unless the seller is using Third-Party Checkout. Some sites may
						require the seller to be VAT registered (see the eBay online help for
						requirements). For digital items, the Item Condition attribute (Item
						Specifics) is not applicable in AttributeSetArray, AttributeArray, or
						LookupAttributeArray. If you pass in the item condition, it will be dropped.
						Fields that specify the item location, shipping details, payment methods other
						than PayPal, gift options, Now and New, and Best Offer are not applicable to
						digitally delivered items.&lt;br&gt;
						&lt;br&gt;
						Digital listings are not eligible for eBay Express.&lt;br&gt;
						&lt;br&gt;
						When you revise or relist an item, if you change the listing format (e.g., to
						Chinese auction) or select a category that does not support this feature, eBay
						will remove the digital delivery option from the listing. As a result, you may
						need to specify different or additional information in the listing details. To
						remove DigitalDeliveryDetails when you modify a listing, use DeletedField. If
						any quantity of a multiple quantity digital delivery listing has been sold,
						the seller cannot remove the digital delivery option, edit the system
						requirements, or alter the delivery method information during the Revise flow.
						&lt;br&gt;&lt;br&gt;
						Not supported for Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DispatchTimeMax" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the maximum number of business days the seller
						commits to for shipping an item to domestic buyers after receiving a
						cleared payment. The seller sets this to an integer value (1, 2, 3,
						4, 5, 10, 15, or 20) corresponding to the number of days. To add
						Get It Fast to listings, in addition to setting GetItFast to true,
						DispatchTimeMax must be set to 1 and the seller must specify at least
						one qualifying expedited shipping service.
						GetItem returns DispatchTimeMax only when shipping service options are
						specified for the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SkypeEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies that Skype-related information is included with an item listing,
						including, for example, Skype Voice. Skype-related information provides
						buttons that enable potential buyers to contact sellers through Skype.
						Information about Skype is available at www.Skype.com. If all of the
						prerequisites for adding Skype buttons to listings are met (see the eBay Web
						Services Guide), you can make communication through Skype available in
						listings. SkypeEnabled must be true if SkypeID and SkypeContactOption are
						specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SkypeID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The Skype name of the seller. Requires that SkypeEnabled is set to true.
						Available if the seller has a Skype account and has linked it (on the eBay
						site) with his or her eBay account.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SkypeOption" type="ns:SkypeOptionCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Deprecated; use SkypeContactOption instead. If you use SkypeOption when adding
						an item, it is mapped to the corresponding values of SkypeContactOption.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SkypeContactOption" type="ns:SkypeContactOptionCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Specifies the Skype contact options supported. Requires that SkypeEnabled is
						set to true. Available if the seller has a Skype account and has linked it (on
						the eBay site) with his or her eBay account.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates, when true, that an item is available by Best Offer.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalListing" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates, when true, that an item is available locally.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ThirdPartyCheckoutIntegration" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Only authorized Third-Party Checkout providers can use this flag.
						&lt;br&gt;&lt;br&gt;
						IMPORTANT: If you are not authorized to support Third Party Checkout and your
						application is not the original listing application, never specify
						ThirdPartyCheckout or ThirdPartyCheckoutIntegration in your request (even if
						you revise a listing that already includes these flags). Otherwise, the
						listing may be dropped from Express or you may get unexpected
						results.&lt;br&gt;
						&lt;br&gt;
						A Third-Party Checkout provider uses this flag in two ways:&lt;br&gt;
						&lt;br&gt;
						1) Set this flag to true to specify that you consent to use the Checkout
						notification (or calls like GetSellerTransactions and GetItemTransactions) to
						obtain data about eBay Express sales from the item, and to confirm that buyers
						will use the Express shopping cart for checkout processing without being
						redirected to your Third-Party Checkout site. If ThirdPartyCheckout is true,
						the ThirdPartyCheckoutIntegration field must also be true if you want an
						eligible listing to be included on eBay Express (and the Third Party Checkout
						checkout flow will be then be ignored for Express purchases). See "eBay
						Express" in the eBay Web Services Guide.&lt;br&gt;
						&lt;br&gt;
						In other words, assuming the seller and item meet all other eligibility
						requirements for Express, the seller opts into Express,
						and the seller (optionally) subscribes to the Checkout notification:&lt;br&gt;
						- If ThirdPartyCheckout == true
						   and ThirdPartyCheckoutIntegration == true,
						   the item will be listed on Express
						   and Checkout notifications will be sent.&lt;br&gt;
						- If ThirdPartyCheckout == true
						   and ThirdPartyCheckoutIntegration == omitted or false,
						   the item will be disqualified for Express
						   and no Checkout notification will be sent.&lt;br&gt;
						- If ThirdPartyCheckout == omitted or false,
						   and ThirdPartyCheckoutIntegration == true,
						   the item will be listed on Express
						   and Checkout notifications will be sent.&lt;br&gt;
						- If ThirdPartyCheckout == omitted or false,
						  and ThirdPartyCheckoutIntegration == omitted or false,
						  the item will be listed on Express
						   but no Checkout notifications will be sent.&lt;br&gt;
						   &lt;br&gt;
						2) If you subscribe to the Checkout notification, set this flag to true to
						enable Checkout notifications for a particular listing. These notifications
						can be sent for any transaction created from the listing, regardless of
						whether the listing is included on Express and regardless of the value of
						ThirdPartyCheckout. Checkout notifications are not sent if
						ThirdPartyCheckoutIntegration is false.&lt;br&gt;
						&lt;br&gt;
						Returned only if true for a listing.&lt;br&gt;
						&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>false</Default>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Listing Criteria for eBay Express</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressListingCriteria</URL>
						</SeeLink>
						<SeeLink>
							<Title>Third Party Checkout and eBay Express</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ThirdPartyCheckoutIntegration</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressOptOut" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Preference to opt out an individual fixed price or Store Inventory item from
						eBay Express. Specify as input when listing an item to indicate that the item
						should not be listed on eBay Express. By default, an item is opted in unless
						the seller has configured their user preferences to opt all items out of
						Express (see GetUserPreferences). So, if the seller and item qualify for eBay
						Express, the item will be made available on the Express site unless you set
						this flag to true to opt out.&lt;br&gt;&lt;br&gt; ExpressOptOut has no effect
						if the seller opts out in their user preferences. Also, you cannot set
						ExpressOptOut to false to force an ineligible item to be included on
						Express.&lt;br&gt;&lt;br&gt; Coming soon: For Express Germany, this value is
						ignored for Express format listings. That is, sellers cannot opt out of
						Express when listing in the Express-only format.
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>Listing Criteria for eBay Express</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressListingCriteria</URL>
						</SeeLink>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>false</Default>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingCheckoutRedirectPreference" type="ns:ListingCheckoutRedirectPreferenceType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ProStores listing level preferences regarding the store to which
						checkout should be redirected for the listing if ThirdPartyCheckout
						is true.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressDetails" type="ns:ExpressDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Additional item details that only appear in eBay Express search results.
						In GetSearchResultsExpress, only returned when ItemDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element  name="SellerContactDetails" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<CallName>RelistItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalQuestionCount" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProxyItem" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ItemTypeFilterCodeList.xsd #####

-->
	<xs:simpleType name="ItemTypeFilterCodeType">
		<xs:annotation>
			<xs:documentation>
				ItemTypeFilterCodeType - Type declaration to be used by other
				schema. This code identifies the ItemTypeFilters (e.g., for
				GetSearchResults requests) used to filter items returned by the type
				of listing.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AuctionItemsOnly">
				<xs:annotation>
					<xs:documentation>
						(in) Only retrieve listings eligible for competitive bidding at auction.
						That is, only retrieve listings for which ListingType is Chinese, Dutch, or Live
						(regardless of the BuyItNowEnabled value).
						If a listing has a ListingType of any of the following,
						it is not retrieved: StoresFixedPrice, FixedPriceItem, and AdType.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPricedItem">
				<xs:annotation>
					<xs:documentation>
						(in) Whether StoresFixedPrice items are retrieved depends on the site default.
						Only retrieves listings that can be purchased at a fixed price.
						That is, only retrieves listings for which ListingType is StoresFixedPrice or FixedPriceItemStore.
						Also retrieves Chinese and Dutch auction listings for which BuyItNowEnabled is true.
						Does not retrieve listings for which ListingType is AdType or Live,
						and does not retrieve auction listings for which BuyItNowEnabled is false.  
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllItems">
				<xs:annotation>
					<xs:documentation>
						(in) It is recommended that you use AllItemTypes instead of AllItems.
						Return all listing types (the default for GetSearchResults).
						Whether StoresFixedPrice items are retrieved depends on the site default.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoreInventoryOnly">
				<xs:annotation>
					<xs:documentation>
						(in) Only retrieve listings for which ListingType is StoresFixedPrice.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPriceExcludeStoreInventory">
				<xs:annotation>
					<xs:documentation>
						(in) Exclude listings that have ListingType set to StoresFixedPrice.
						Exclude listings that have ListingType set to AdType or Live.
						Exclude auction listings in which BuyItNowEnabled is false.  
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExcludeStoreInventory">
				<xs:annotation>
					<xs:documentation>
						(in) Exclude listings that have ListingType set to StoresFixedPrice. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllItemTypes">
				<xs:annotation>
					<xs:documentation>
						(in) Retrieve listings whether or not ListingType is set to StoresFixedPrice; include auction items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllFixedPriceItemTypes">
				<xs:annotation>
					<xs:documentation>
						(in) Retrieves fixed-price items.
						Whether StoresFixedPrice items are retrieved does not depend on the site default.
						Retrieves listings whether or not ListingType is set to StoresFixedPrice.
						Does not retrieve listings for which ListingType is AdType or Live.
						Does not retrieve auction listings for which BuyItNowEnabled is false.  
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClassifiedItemsOnly">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/LabelType.xsd #####

-->
	<xs:complexType name="LabelType">
<xs:annotation>
	<xs:documentation>
		Applicable when working with Pre-filled Item Information (Catalogs) functionality.
		The label to display when presenting the attribute to a user.
		Not necessarily the same as the attribute's label as defined in the
		characteristic set (i.e., the label could be overridden by the catalog).
	</xs:documentation>
</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The label to display when presenting the attribute to a user (e.g., "Title" or "Manufacturer"). 
            The label is defined for the product, and is therefore not necessarily the same as the label 
						that is defined in the characteristic set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchPage</CallName>
							<CallName>GetProductSearchResults</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="visible" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
         If true, the label name is visible on the eBay site. If false, the label is not visible. 
         Usage of this information is optional. You are not required to display labels in 
         the same manner as eBay. 
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetProductFamilyMembers</CallName>
						<CallName>GetProductSearchPage</CallName>
						<CallName>GetProductSearchResults</CallName>
						<DetailLevels>ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingAnalyzerRecommendationsType.xsd #####

-->
	<xs:complexType name="ListingAnalyzerRecommendationsType">
		<xs:annotation>
			<xs:documentation> 
	         (out) Contains results returned from the Listing Analyzer recommendation engine.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingTipArray" type="ns:ListingTipArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (out) A collection of tips returned from the Listing Analyzer recommendation engine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingCheckoutRedirectPreferenceType.xsd #####

-->
	<xs:complexType name="ListingCheckoutRedirectPreferenceType">
		<xs:annotation>
			<xs:documentation>
				ProStores listing level preferences.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ProStoresStoreName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of the store, if Item.ThirdPartyCheckout is true.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingDesignerType.xsd #####

-->
	<xs:complexType name="ListingDesignerType">
		<xs:annotation>
			<xs:documentation>
        Contains the IDs for the Listing Designer theme and template (if either are
				used) associated with an item, which can optionally be used to enhance the
				appearance of the item's description. Cannot be used with Photo Display. With
				compatibility levels 439 or higher, specified in PictureDetails.PhotoDisplay.
				With lower compatibility levels, specified in SiteHostedPictureType.PhotoDisplay
        or VendorHostedPictureType.PhotoDisplay.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LayoutID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Identifies the Layout template to use when displaying the
            item's description. When relisting an item, LayoutID
            is removed from the listing if you specify ListingDesignerType
            without LayoutID. Call GetDescriptionTemplates for valid IDs.
            Set to false in GetDescriptionTemplates (or do not specify
            LayoutID) to get the standard layout. If a Listing Designer
            layout is used (except standard layout), PhotoDisplayType must
            be false (or not be specified).
			  	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="OptimalPictureSize" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            If true, indicates that the item's picture will be enlarged to fit description
            of the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ThemeID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID for the Listing Designer theme template to use when
						displaying the item's description.
            When relisting, if you specify ListingDesignerType without
            ThemeID, ThemeID is removed from the listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingDetailsType.xsd #####

-->
	<xs:complexType name="ListingDetailsType">
		<xs:annotation>
			<xs:documentation>
				Various details about a listing. Some of the details are calculated or derived after
				an item is listed. The details in this type include the start and end time and
				the converted (localized) prices. The details in this type also include
				input values applicable to the Best Offer feature.
				Additional details in this type include flags indicating if a seller
				specified fields whose values are not visible to the requesting user.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Adult" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) If true, the item is listed in a Mature category. Users must accept
						the Mature Category agreement on the eBay site to retrieve
						items listed in Mature categories. (Users do not need to sign
						this agreement to be able to list items in Mature Categories.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BindingAuction" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Applicable for Real Estate auctions only. If true, buyers and sellers
						are expected to follow through on the sale. If false, bids for the
						Real Estate auction are only expressions of interest.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CheckoutEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates whether checkout is enabled for this item. If true, indicates
						that the seller elects to allow the item purchase to go through the
						checkout process, if the buyer chooses to do so.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<SeeLink>
							<Title>Checkout</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=Checkout</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedBuyItNowPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Converted value of the BuyItNowPrice in the currency of
						the site that returned this response.
						For active items, refresh this value every 24 hours to
						pick up the current conversion rates.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>SecondChanceOffer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedStartPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Converted value of the StartPrice in the currency of
						the site that returned this response.
						For active items, refresh this value every 24 hours to
						pick up the current conversion rates.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedReservePrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Converted value of the ReservePrice in the currency of the
						site that returned this response. Only returned for listings with
						a reserve price when the requesting user is the listing's seller.
						For active items, refresh this value every 24 hours to
						pick up the current conversion rates.
						Not applicable to Fixed Price and Store Inventory listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HasReservePrice" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) If true, the seller specified a value in ReservePrice.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RegionName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Obsolete: the use of regions for locating items is being phased out and
						has been replaced on most sites by distance-based searching and searches
						by location. Some sites, such as the China site, still use region. Although
						all sites will still allow you to specify Item.RegionID in AddItem when
						listing an item, only those sites that support the use of regions will
						return RegionName in the response for GetItem, and the region information
						will not appear on or be used by the web site. For sites that no longer
						support the use of regions, use Address.PostalCode and Item.Location instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<NoCalls/>
							<TagStatus>Obsolete</TagStatus>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RelistedItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates the new item ID for a re-listed item. When an item is
						re-listed, the item ID for the new (re-list) item is added to the
						old (expired) listing to provide buyers a means to navigate to
						the new listing. This value only appears when the old listing is
						retrieved.
						Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SecondChanceOriginalItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The item ID for the original listing from which a second chance offer
						is made. This value is only returned when the data for the second chance
						offer listing is retrieved.
						Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Time stamp (in GMT) that eBay recorded as the moment that
						the listing became available for bidding or buying.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Context>ActiveList</Context>
							<Context>ScheduledList</Context>
							<Context>Transaction</Context>
							<Context>UnsoldList</Context>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="EndTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Time stamp (in GMT) when the listing is scheduled to end
						(calculated based on the values of StartTime and ListingDuration)
						or the actual end time if the item has ended.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>SecondChanceOffer</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>Transaction</Context>
							<Context>UnsoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ViewItemURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The URL of the Web page where a user can view the listing.
						On the US site, this is called the "View Item" page.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HasUnansweredQuestions" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			      (out) Indicates whether the item has any unanswered questions. Use GetMemberMessages to
			      retrieve unanswered questions for the item if this flag indicates that there
			      are any.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HasPublicMessages" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			      (out) Indicates whether the item has any publicly displayed messages. Use GetMemberMessages
			      to retrieve public messages for the item if this flag indicates that there are any.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyItNowAvailable" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			      (out) Indicates whether, for a Dutch Auction, there is a Buy It Now option. Germany site (site ID 77) and China site (site ID 223) only.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerBusinessType" type="ns:SellerBusinessCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Type of seller account. This value can be returned if the German site (site ID 77) or eBay Motors site (site ID 100) is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumBestOfferPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies the minimum acceptable best offer price. If a buyer
						submits a best offer that is below this value, the offer is automatically
						declined by the seller. Applies only to items listed in categories that
						support the Best Offer Auto-Decline feature. Best Offer must be enabled
						for the item, and only the seller who listed the item can see this value.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumBestOfferMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies the message sent from the seller to the buyer when a
						submitted best offer is automatically declined by the seller. A best offer
						is automatically declined if it does not meet the minimum acceptable best
						offer price specified by the seller with MinimumBestOfferPrice. Applies only
						to items listed in categories that support the Best Offer Auto-Decline
						feature. Best Offer must be enabled for the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalListingDistance" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies a distance in miles. This distance is used as the radius
						of the area about the supplied postal code that constitutes the
						local market. Local listings are limited to a distance of 100 miles.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressListing" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					If true, the item appears on the eBay Express site associated with the item's
					listing site (US or Germany).
					</xs:documentation>
					<xs:appinfo>
						<SeeLink>
							<Title>Retrieving eBay Express Listings</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressGetItem</URL>
						</SeeLink>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TCROriginalItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates the item ID of the original item listing from which a Transaction Confirmation Request
						(TCR) was created. This value is only returned when the data for a TCR is retrieved.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingDurationCodeList.xsd #####

-->
	<xs:simpleType name="ListingDurationCodeType">
		<xs:annotation>
			<xs:documentation>
			Applications should not depend on the completeness of ListingDurationCodeType.
			GetCategoryFeatures will return the complete list of listing durations.
			Each code in this code list specifies a number of days that a listing can be
			active (i.e., available for bidding/buying). The validity of a code
			depends on the listing type.
			Call GetCategoryFeatures to determine which listing formats
			support each duration for the site you are using.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Days_1">
				<xs:annotation>
					<xs:documentation>
					(in/out) 1 Day - A seller must have a positive feedback rating of 10 or
					more or must be ID Verified to use the 1-day listing duration on the US
					site. Typically applicable for Chinese and Dutch auction formats (including Real
					Estate) and Personal Offer (Second Chance Offer).
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_3">
				<xs:annotation>
					<xs:documentation>
					(in/out) 3 Days - Typically applicable to Chinese, Dutch, and Live auction formats
					(including Real Estate); Personal Offer (Second Chance Offer); and Basic
					Fixed-Price format.
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_5">
				<xs:annotation>
					<xs:documentation>
					(in/out) 5 Days - Typically applicable to Chinese, Dutch, and Live auction formats
					(including Real Estate); Personal Offer (Second Chance Offer); and Basic
					Fixed-Price format.
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_7">
				<xs:annotation>
					<xs:documentation>
					(in/out) 7 Days - Typically applicable to Chinese, Dutch, and Live auction formats
					(including Real Estate); Personal Offer (Second Chance Offer); and Basic
					Fixed-Price format.
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_10">
				<xs:annotation>
					<xs:documentation>
						(in/out) 10 Days - Subject to an additional listing upgrade fee. 
						Typically applicable to Chinese, Dutch, and Live auction formats 
						(including Real Estate) and Basic Fixed-Price format.
						Call GetCategoryFeatures to determine which listing formats
						support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_14">
				<xs:annotation>
					<xs:documentation>
					(in/out) 14 Days - Subject to an additional listing upgrade fee. 
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_21">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_30">
				<xs:annotation>
					<xs:documentation>
					(in/out) 30 Days - Typically applicable to Real Estate Ad format and Store Inventory
					format. Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		<xs:enumeration value="Days_60">
				<xs:annotation>
					<xs:documentation>
					(in/out) Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_90">
				<xs:annotation>
					<xs:documentation>
					(in/out) 90 Days - Typically applicable to Real Estate Ad format. 
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_120">
				<xs:annotation>
					<xs:documentation>
					(in/out)	Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GTC">
				<xs:annotation>
					<xs:documentation>
					(in/out) GTC  - Relist automatically every 30 days until all the items sell
					or the seller ends the listing. Typically applicable to Store Inventory format 
					and Half.com listings.
					Call GetCategoryFeatures to determine which listing formats
					support this duration for the site you are using.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ListingDurationDefinitionType.xsd #####

-->
	<xs:complexType name="ListingDurationDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				A container node for a set of durations that apply to a certain listing type.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Duration" type="xs:token" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Specifies the length of time an auction can be open, in days. The allowed durations 
						vary according to the type of listing. The value GTC means Good Til Canceled. 
					</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryFeatures</CallName>
						<DetailLevels>ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="durationSetID" type="xs:int">
			<xs:annotation>
				<xs:documentation>
					Identifies the type of listing to which the set of durations applies. The durationSetID value corresponds to the listing types returned in  Category.ListingDuration (also in the call response).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryFeatures</CallName>
						<DetailLevels>ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingDurationDefinitionsType.xsd #####

-->
	<xs:complexType name="ListingDurationDefinitionsType">
		<xs:annotation>
			<xs:documentation> 
				A container node for sets of durations, each set describing the durations allowed for
				one listing type.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingDuration" type="ns:ListingDurationDefinitionType" minOccurs="0" maxOccurs="unbounded">
			<xs:annotation>
				<xs:documentation>
					Contains the duration periods that apply to a certain listing type.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryFeatures</CallName>
						<DetailLevels>ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
			</xs:element>
		</xs:sequence>
		<xs:attribute name="Version" type="xs:int">
			<xs:annotation>
				<xs:documentation>
					The current version of the feature. Some features (for example, ShippingTermsRequired) 
					do not have version numbers. 
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetCategoryFeatures</CallName>
						<DetailLevels>ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingDurationReferenceType.xsd #####

-->
	<xs:complexType name="ListingDurationReferenceType">
		<xs:annotation>
			<xs:documentation>
				Identifies the type of listing as an attribute on the ListingDuration node.
			</xs:documentation>
		</xs:annotation>
		<xs:simpleContent>
			<xs:extension base="xs:int">
				<xs:attribute name="type" type="ns:ListingTypeCodeType">
					<xs:annotation>
						<xs:documentation>
							The type of listing a set of durations describes.
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetCategoryFeatures</CallName>
								<DetailLevels>ReturnAll</DetailLevels>
								<Returned>Conditionally</Returned>
							</CallInfo>
						</xs:appinfo>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:simpleContent>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingEnhancementsCodeList.xsd #####

-->
	<xs:simpleType name="ListingEnhancementsCodeType">
		<xs:annotation>
			<xs:documentation>
				ListingEnhancementsCodeType - Type declaration to be used by other
				schema. Indicates optional featuring properties of an item.
				Featuring properties make a listing stand out in a search or listing
				page, or let the item be featured on the eBay home page.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Border">
				<xs:annotation>
					<xs:documentation>
						(in/out) If specified, the seller wants the item to be displayed with a border that goes
						around the item in search result pages that return multiple items.
						The border differentiates the item from other items in the list.
						Applicable listing fees apply.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BoldTitle">
				<xs:annotation>
					<xs:documentation>
						(in/out) If specified, the seller wants the title for the item's listing to 
						be in boldface type. Applicable listing fees apply. 
						Does not affect the item subtitle (Item.SubTitle), if any.
						Not applicable to eBay Motors. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Featured">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is a &quot;Featured Plus&quot; item.
						The item will display prominently in the Featured Items section of its category list, 
						and it will stand out on search results pages. It will also display in the regular, 
						non-featured item list. Only available to users with a Feedback rating of 10 or greater. 
						Not applicable to eBay Motors listings. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Highlight">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is highlighted in a different color in lists.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HomePageFeatured">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing will have a chance to rotate into a special display 
						on eBay's Home page. Your item is very likely to show up on the Home page, 
						although eBay does not guarantee that your item will be highlighted 
						in this way. This is the highest level of visibility on eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackBundle">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is using ProPackBundle (a feature pack). Applies only to US and Canadian eBay motor vehicle sellers. Contains the BoldTitle, Border, Featured and Highlight features.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BasicUpgradePackBundle">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is using BasicUpgradePackBundle (a feature pack). Australia site (site ID 15, abbreviation AU) only. Effective beginning February 22, 2006. Contains the Gallery and Subtitle features.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ValuePackBundle">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is using ValuePack bundle (a feature pack),
						which combines the features Gallery, Subtitle, and Listing Designer for a discounted price. Support for this feature varies by site and category. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProPackPlusBundle">
				<xs:annotation>
					<xs:documentation>
						(in/out) Listing is using ProPackPlus bundle (a feature pack),
						which combines the features BoldTitle, Border, Highlight, Featured, and Gallery for a discounted price. Support for this feature varies by site and category. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:annotation>
				<xs:documentation>
					eBay Listing Enhancements Codes
				</xs:documentation>
			</xs:annotation>
	<xs:annotation>
				<xs:documentation>
					Code List Agency - eBay, Inc.
				</xs:documentation>
			</xs:annotation>
	<xs:annotation>
				<xs:documentation>
					Code List Version - 1.0
				</xs:documentation>
			</xs:annotation>
<!--  

##### from file eBLBaseComponents/public/ListingFlowCodeList.xsd #####

-->
	<xs:simpleType name="ListingFlowCodeType">
		<xs:annotation>
			<xs:documentation>
ListingFlowCodeType - Type declaration to be used by other schema.
Identifies the listing flows on the eBay Web site for use with calls like
GetItemRecommendations.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AddItem">
				<xs:annotation>
					<xs:documentation>
                (in) AddItem (Sell Your Item) listing flow.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReviseItem">
				<xs:annotation>
					<xs:documentation>
                (in) ReviseItem (Revise Your Item) listing flow.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RelistItem">
				<xs:annotation>
					<xs:documentation>
                (in) RelistItem listing flow.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ListingStatusCodeList.xsd #####

-->
	<xs:simpleType name="ListingStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies an active or ended listing's status in eBay's processing
				workflow. If a listing ends with a sale (or sales), eBay needs to
				update the sale details (e.g., total price and buyer/high bidder)
				and the final value fee. This processing can take several minutes.
				If you retrieve a sold item and no details about the buyer/high
				bidder are returned or no final value fee is available, use this
				listing status information to determine whether eBay has finished
				processing the listing.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
						(out) The listing is still active or the listing has ended with
						a sale but eBay has not completed processing the sale details
						(e.g., total price and high bidder). A multi-item listing is
						considered active until all items have winning bids or
						purchases or the listing ends with at least one winning bid or
						purchase. If the listing has ended with a sale but this Active
						status is returned, please allow several minutes for eBay to
						finish processing the listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetHighBidders</CallName>
							<CallName>GetAllBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Ended">
				<xs:annotation>
					<xs:documentation>
						(out) The listing has ended. If the listing ended with a sale,
						eBay has completed processing of the sale. All sale information
						returned from eBay (e.g., total price and high bidder) should be
						considered accurate and complete. However, the final value fee is
						not yet available.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetHighBidders</CallName>
							<CallName>GetAllBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Completed">
				<xs:annotation>
					<xs:documentation>
						(out) The listing has closed and eBay has completed processing
						the sale. All sale information returned from eBay (e.g., total
						price and high bidder) should be considered accurate and
						complete.
						Although the Final Value Fee for FixedPriceItem, StoresFixedPrice,
						and Buy It Now Dutch listing types is returned by
						GetSellerTransactions and GetItemTransactions on a transaction by
						transaction basis, all other listing types, including Chinese and
						Dutch (no Buy It Now purchases), require the listing status to be
						Completed before the Final Value Fee is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetHighBidders</CallName>
							<CallName>GetAllBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Custom">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ListingSubtypeEnum.xsd #####

-->
	<xs:simpleType name="ListingSubtypeEnum">
	<xs:annotation>
		<xs:documentation>
			Indicates the specific type of lead generation format listing (i.e., classified 
			subtypes).
		</xs:documentation>
	</xs:annotation>
	<xs:restriction base="xs:token">
		<xs:enumeration value="ClassifiedAd">
			<xs:annotation>
				<xs:documentation>
					Reserved for future use.
				</xs:documentation>
			</xs:annotation>
		</xs:enumeration>
	</xs:restriction>		
</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ListingTipArrayType.xsd #####

-->
	<xs:complexType name="ListingTipArrayType">
		<xs:annotation>
			<xs:documentation> 
      (out) Contains a list of tips on improving a listing's details, if any. 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingTip" type="ns:ListingTipType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					An individual tip on improving a listing's details. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingTipFieldType.xsd #####

-->
	<xs:complexType name="ListingTipFieldType">
		<xs:annotation>
			<xs:documentation>
      (out) Identifies the item field that the tip relates to.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingTipFieldID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Identifier associated with the item field. Primarily for internal use. This value may change over time.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FieldTip" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Related text that appears near a field or at the top of the section within which
            the field appears in the selling flow.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>125</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CurrentFieldText" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A label used to preface the current value of a field. For example,
            "Current value" would be the CurrentValueText in "Current value: 25".
            If no label exists, this element is not returned.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>50</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CurrentFieldValue" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
             Current value of the field (in the listing or in the candidate item) or meta-data about the value.
             For example, if the tip is recommending a longer item title, the CurrentFieldValue might specify
             the current length of the title. If no current value is available, this information is not returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingTipMessageType.xsd #####

-->
	<xs:complexType name="ListingTipMessageType">
		<xs:annotation>
			<xs:documentation>
      (out) Contains the message portion of a listing tip that is returned by the Listing Analyzer engine.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingTipMessageID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
              Identifier for the tip message. Primarily for internal use. This value may change over time.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShortMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
              Brief version of the tip message.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>125</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LongMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Detailed version of the tip message.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>125</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HelpURLPath" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Path part of a URL for a "Learn More" link that points to a relevant eBay Web site online help page.
            The path is relative to http://pages.ebay.XX, where XX is the 2-letter site code
            (e.g., http://pages.ebay.de for the eBay Germany site). Applications should append the
            URL to the appropriate path for the user's site.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>125</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingTipType.xsd #####

-->
	<xs:complexType name="ListingTipType">
		<xs:annotation>
			<xs:documentation>
      (out) A tip on improving a listing's details. Tips are returned from the Listing Analyzer engine.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingTipID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Identifier for the tip. Primarily for internal use. This value may change over time. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Priority" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The rank of the tip. All tips are ranked by importance. Ranking varies for each site. 
            The rank is always greater than 0.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Message" type="ns:ListingTipMessageType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The tip's message content.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Field" type="ns:ListingTipFieldType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The item field that is associated with the tip.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ListingTypeCodeList.xsd #####

-->
	<xs:simpleType name="ListingTypeCodeType">
		<xs:annotation>
			<xs:documentation>
Specifies the selling format used for a listing.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unknown">
				<xs:annotation>
					<xs:documentation>
						(out) Unknown auction type.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Chinese">
				<xs:annotation>
					<xs:documentation>
						(in/out) Single-quantity online auction format.
						A Chinese auction has a Quantity of 1. Buyers engage in competitive bidding,
						although Buy It Now may be offered as long as no bids have been placed.
						Online auctions are listed on eBay.com, and they are also listed in
						the seller's eBay Store if the seller is a Store owner.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Dutch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Multiple-quantity online auction format.
						A Dutch auction has a Quantity greater than 1. Buyers engage in
						competitive bidding. Some sites also offer Buy It Now for Dutch auctions.
						Online auctions are listed on eBay.com, and they are also listed in
						the seller's eBay Store if the seller is a Store owner.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Live">
				<xs:annotation>
					<xs:documentation>
						(out) Live auction, on-site auction that can include non-eBay bidders.
						Use AddLiveAuctionItem to list live auctions.
						Live auctions are listed on the eBay Live Auctions site, in live auction categories.
						They can also appear on eBay if the seller lists the lot in a secondary category
						that is an eBay category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Auction">
				<xs:annotation>
					<xs:documentation>
						(in) An optional input parameter used with GetMyeBaySelling. When used in
						the request, returns items of the following auction types: Chinese, Dutch,
						and Live.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>ActiveList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AdType">
				<xs:annotation>
					<xs:documentation>
						(in/out) Advertisement to solicit inquiries on listings such as real estate.
						Permits no bidding on that item, service, or property. To express interest,
						a buyer fills out a contact form that eBay forwards to the the seller as a lead.
						This format does not enable buyers and sellers to transact online through eBay,
						and eBay Feedback is not available for ad format listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>ActiveList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoresFixedPrice">
				<xs:annotation>
					<xs:documentation>
						(in/out) A fixed-price format for eBay Store sellers.
						Store Inventory listings appear after other listings in regular browse and search
						item lists on eBay. They have a lower Insertion Fee and longer listing durations.
						Only available to sellers who have an eBay Store.
						Store Inventory listings are listed on eBay.com, and they are also listed in
						the seller's eBay Store.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>ActiveList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PersonalOffer">
				<xs:annotation>
					<xs:documentation>
						(out) Second chance offer made to a non-winning bidder on an ended listing.
						A seller can make an offer to a non-winning bidder when either the winning bidder
						has failed to pay for an item or the seller has a duplicate of the item.
						A seller can create a Second Chance Offer immediately after a listing ends and up to
						60 days after the end of the listing. eBay does not charge an Insertion Fee,
						but if the bidder accepts the offer, the regular Final Value Fee is charged.
						In the case of an Unpaid Item, the seller should ensure that everything has
						been done to resolve the issue with the winning bidder before sending a
						Second Chance Offer to another bidder. See the Unpaid Items Process for details.
						Make sure you're aware of other rules and restrictions surrounding Second Chance Offers.
						Use AddSecondChanceItem to submit Second Chance Offers.
						Listed on eBay, but does not appear when browsing or searching listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPriceItem">
				<xs:annotation>
					<xs:documentation>
						(in/out) A basic fixed-price format.
						A fixed-price listing with a Quantity of 1 or more. Allows no auction-style bidding.
						Also known as Buy It Now Only on some sites (not to be confused with the BuyItNow option that
						is available for Chinese auctions).
						Sellers need to meet certain feedback requirements and/or be ID Verified to use this format.
						See Minimum Feedback Requirements for Various Features in the eBay Web Services guide.
						Fixed-price listings are listed on eBay.com, and they are also listed in
						the seller's eBay Store if the seller is a Store owner.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<RequiredInput>No</RequiredInput>
							<Context>ActiveList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Half">
				<xs:annotation>
					<xs:documentation>
					(in/out) Half.com listing (item is listed on Half.com, not on eBay).
					You must be a registered Half.com seller to use this format.
					See Working with Half.com Listings in the eBay Web Services guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LeadGeneration">
				<xs:annotation>
					<xs:documentation>
						(in/out) Lead Generation format (advertisement-style listing to solicit
						inquiries or offers, no bidding or fixed price, listed on eBay).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Express">
				<xs:annotation>
					<xs:documentation>
					(in/out) Coming soon for Germany only:
					eBay Express format (item is listed only on eBay Express only, not on eBay).
					You must be a vetted Express Germany seller to use this format.
					See "List Items in a Fixed Price Format" in the eBay Web Services guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/LiveAuctionApprovalStatusArrayType.xsd #####

-->
	<xs:complexType name="LiveAuctionApprovalStatusArrayType">
		<xs:annotation>
			<xs:documentation> 
			Contains the results of the request for each bidder.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LiveAuctionStatus" type="ns:LiveAuctionApprovalStatusType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					Indicates the current approval status of a bidder.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LiveAuctionApprovalStatusType.xsd #####

-->
	<xs:complexType name="LiveAuctionApprovalStatusType">
		<xs:annotation>
			<xs:documentation>
			The approval status of a user who wants to bid on a live auction.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					User ID of the bidder.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The bidder's approval status. Possible values are Approvied, Denied, 
					or a message indicating a problem that prevented the bidder from 
					being approved (or denied), such as an invalid ApproveBiddingLimit value.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ApproveLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LiveAuctionBidArrayType.xsd #####

-->
	<xs:complexType name="LiveAuctionBidArrayType">
		<xs:annotation>
			<xs:documentation> 
        Container for a list of Live Auction Bidders, such as returned by
        GetLiveAuctionBidders. Will contain zero, one, or multiple
        LiveAuctionBidType bidders, each of which represents one bidder's request listing
        that was found by the search.
        Output only.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LiveAuctionBid" type="ns:LiveAuctionBidType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
            Contains data for an item listing found by a search.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LiveAuctionBidType.xsd #####

-->
	<xs:complexType name="LiveAuctionBidType">
		<xs:annotation>
			<xs:documentation> 
        			Contains the data for one listing found by a search .
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="RequestedBiddingLimit" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Amount that user has requested for the approval.
					This is returned if the auction house has requested that the bidder 
					enter an amount for the approval.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BidderStatus" type="ns:BidderStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether the user is "approved","denied", or "pending" or a combination of these.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ApprovedBiddingLimit" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Amount that has been approved by the seller.
					If the seller has not yet approved, return value "Pending"
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeclinedComment" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Comments entered by the seller when it declined an approval request, if any.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LiveAuctionCatalogType.xsd #####

-->
	<xs:complexType name="LiveAuctionCatalogType">
		<xs:annotation>
			<xs:documentation>
      (out) Describes one live auction catalog and its sale schedules.
      Use this information to determine an appropriate combination of catalog and schedule IDs
      in which to list a lot item when you use AddLiveAuctionItem.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserCatalogID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) ID number identifiying a specific eBay Live Auctions catalog that the user has created.
            Pass as input to AddLiveAuctionItem when you list a lot item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionCatalogDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CatalogName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (out) Descriptive name that the seller created for the catalog.
            Pass as input to AddLiveAuctionItem when you list a lot item.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>45</MaxLength>
						<CallInfo>
							<CallName>GetLiveAuctionCatalogDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Schedule" type="ns:ScheduleType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            (out) Describes a single live auction sale schedule that the user defined.
            A seller can define a maximum of 5 schedules for each catalog.
            Each schedule defines the start and end time of a live auction event.
            (Only the start time is returned from GetLiveAuctionCatalogDetails.)
            A schedule must be created at least 48 hours in advance of the auction.
            The seller then lists one or more lots that will be auctioned during that event.
            Only schedules for future sales are returned. That is, schedules for
            ended sales or sales in progress are not returned.
            Pass as input to AddLiveAuctionItem when you list a lot item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionCatalogDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LiveAuctionDetailsType.xsd #####

-->
	<xs:complexType name="LiveAuctionDetailsType">
		<xs:annotation>
			<xs:documentation> 
      (in) Describes the live auction-specific details of a lot item.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserCatalogID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) Number that identifies the seller's eBay Live Auctions catalog 
            within which the lot item will be listed. Use GetLiveAuctionCatalogDetails 
            to determine the seller's available catalog IDs.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ScheduleID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) Number that identifies the sale schedule for the lot. The schedule ID must be 
            for a pending sale associated with the catalog identified in UserCatalogID. 
            Call GetLiveAuctionCatalogDetails to determine the valid schedule IDs for the catalog.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LotNumber" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) Lot number defined by the seller. Each lot number must be unique within the schedule. 
            A lot number can consist of 1-10 alphanumeric characters beginning with a 
            number from 0-9. If all values are numbers, the highest allowed value is 2147483647.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>						
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HighEstimate" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) Highest appraised value for the item. 
            Must be greater than zero and greater than the value in LowEstimate. 
            (Pass an integer value only, not a double.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>						
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LowEstimate" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) Lowest appraised value for the item. Must be greater than zero and 
            less than the value in HighEstimate.
            (Pass an integer value only, not a double.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>						
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LocalMarketNonSubscriptionDefinitionType.xsd #####

-->
	<xs:complexType name="LocalMarketNonSubscriptionDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the LocalMarketNonSubscription feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LocalMarketPremiumSubscriptionDefinitionType.xsd #####

-->
	<xs:complexType name="LocalMarketPremiumSubscriptionDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the LocalMarketPremiumSubscription feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LocalMarketRegularSubscriptionDefinitionType.xsd #####

-->
	<xs:complexType name="LocalMarketRegularSubscriptionDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the LocalMarketRegularSubscription feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LocalMarketSpecialitySubscriptionDefinitionType.xsd #####

-->
	<xs:complexType name="LocalMarketSpecialitySubscriptionDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the LocalMarketSpecialitySubscription feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LocalSearchType.xsd #####

-->
	<xs:complexType name="LocalSearchType">
		<xs:annotation>
			<xs:documentation>
					Contains data for filtering a search by proximity.
				</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MaxDistance" type="xs:int">
				<xs:annotation>
					<xs:documentation>
							The maximum distance from the specified postal code to search for items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PostalCode" type="xs:string">
				<xs:annotation>
					<xs:documentation>
							The postal code to use as the basis for the proximity search.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>							
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LogoTypeCodeList.xsd #####

-->
	<xs:simpleType name="LogoTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="WinningBidderNotice"/>
			<xs:enumeration value="Store"/>
			<xs:enumeration value="Custom"/>
			<xs:enumeration value="CustomCode"/>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/LookupAttributeArrayType.xsd #####

-->
	<xs:complexType name="LookupAttributeArrayType">
		<xs:annotation>
			<xs:documentation> 
       Only valid when using AddItem for items in Media categories 
       (Books, DVD and Movies, Music, and Video Game categories). 
       You can pass either AttributeSetArrayType or 
       LookupAttributeArrayType, but you cannot pass both containers in the same request.
       See the eBay Web Services guide for additional information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LookupAttribute" type="ns:LookupAttributeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
					The condition of the item.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
					  <CallName>AddItem</CallName>
					  <CallName>GetItemRecommendations</CallName>
					  <CallName>RelistItem</CallName>
					  <CallName>VerifyAddItem</CallName>
					  <RequiredInput>No</RequiredInput>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/LookupAttributeType.xsd #####

-->
	<xs:complexType name="LookupAttributeType">
		<xs:annotation>
			<xs:documentation> 
          (in) An optional attribute that the seller wants to include in the listing. 
          Enables you to specify an attribute by name rather than by ID.
          Only valid in Media categories (Books, DVD and Movies, Music, and Video Game categories).
          Currently, only the Condition attribute is supported.
				</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) The literal name of the attribute. Pass "Condition" (without quotes).
            Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>GetItemRecommendations</CallName>
						  <CallName>RelistItem</CallName>
						  <CallName>VerifyAddItem</CallName>						  
						  <RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Value" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            (in) The literal name of the attribute value. Pass "New" or "Used" (without quotes).
            Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>GetItemRecommendations</CallName>
						  <CallName>RelistItem</CallName>
						  <CallName>VerifyAddItem</CallName>						  
						  <RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MailOptionsTypeCodeList.xsd #####

-->
	<xs:simpleType name="MailOptionsTypeCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="DoNotSendEmail">
			</xs:enumeration>
			<xs:enumeration value="EmailCopyToSender">
			</xs:enumeration>
			<xs:enumeration value="HideSenderEmailAddress">
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MarkUpMarkDownEventType.xsd #####

-->
	<xs:complexType name="MarkUpMarkDownEventType">
		<xs:annotation>
			<xs:documentation> 
				Describes an individual mark-up or mark-down event. eBay will automatically 
				mark an application as down if attempts to deliver a notification fail 
				repeatedly. eBay may mark an application down manually under certain 
				circumstances. 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Type" type="ns:MarkUpMarkDownEventTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Whether the application has been marked up or marked down.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Time" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Time when the application was marked up or marked down.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Reason" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Describes how the application was marked down, automatically or 
						manually. When an application is automatically marked down, eBay will 
						ping the application periodically, and if communication is restored, eBay 
						will automatically mark the application up. If your application is marked 
						down manually, you must contact eBay Developer Support to get your 
						application marked up. A Reason is not provided for mark up events.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MarkUpMarkDownEventTypeCodeList.xsd #####

-->
	<xs:simpleType name="MarkUpMarkDownEventTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				Valid application status codes, either MarkUp (application was marked up, 
				communication is restored) or MarkDown (application was marked down, no 
				communication).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="MarkUp">
				<xs:annotation>
					<xs:documentation>
						(out) Status indicating the application was or is marked up.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarkDown">
				<xs:annotation>
					<xs:documentation>
						(out) Status indicating the application was marked down.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for future internal or external use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MarkUpMarkDownHistoryType.xsd #####

-->
	<xs:complexType name="MarkUpMarkDownHistoryType">
		<xs:annotation>
			<xs:documentation>
				List of objects representing markup or markdown events for a given application 
				and time period. If no time period is specified in the request, the information 
				for only one day (24 hours before the time the call is made to the time the call 
				is made) is included. The maximum time period is allowed is 3 days (72 hours 
				before the call is made to the time the call is made). 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MarkUpMarkDownEvent" type="ns:MarkUpMarkDownEventType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Details for a MarkDown or MarkUp event.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MaximumItemRequirementsType.xsd #####

-->
	<xs:complexType name="MaximumItemRequirementsType">
		<xs:annotation>
			<xs:documentation>
				Container for items bid.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MaximumItemCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If this field is present, blocking is enabled,
						where the value of this field represents the
						maximum number of this seller's items a bidder is allowed to bid
						on in a 10 day period before being blocked.
						Valid values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 50, 75, 100.
					</xs:documentation>
					<xs:appinfo>
						<Min/>
						<Max/>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumFeedbackScore" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) This field is ignored on input unless MaximumItemCount has
						been provided.
						If this field is present, the user's feedback score is also considered:
						a user is blocked from bidding if the user's feedback score is
						less than or equal to the value of this field.
						Valid values: 0, 1, 2, 3, 4, 5.
					</xs:documentation>
					<xs:appinfo>
						<Min/>
						<Max/>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MemberMessageExchangeArrayType.xsd #####

-->
	<xs:complexType name="MemberMessageExchangeArrayType">
		<xs:annotation>
			<xs:documentation>
				Container for messages. Returned for GetMemberMessages if messages that meet the request criteria exist.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MemberMessageExchange" type="ns:MemberMessageExchangeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Information about individual messages. Returned if the parent container is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMemberMessages</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MemberMessageExchangeType.xsd #####

-->
	<xs:complexType name="MemberMessageExchangeType">
	<xs:annotation>
		<xs:documentation>
			Container for message metadata.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="Item" type="ns:ItemType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The item about which the question was asked. Returned if the parent container is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Question" type="ns:MemberMessageType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Contains all the information about the question being asked.  Returned if the parent container is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Response" type="xs:string" minOccurs="0" maxOccurs="unbounded">
			<xs:annotation>
				<xs:documentation>
					An answer to the question. Returned if the parent container is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="MessageStatus" type="ns:MessageStatusTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The status of the message. Returned if the parent container is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CreationDate" type="xs:dateTime" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Date the message was created. Used to filter response. Returned if the parent container is returned.
				</xs:documentation>
			</xs:annotation>
		</xs:element>
		<xs:element name="LastModifiedDate" type="xs:dateTime" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Date the message was last modified. Returned if the parent container is returned.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MemberMessageType.xsd #####

-->
	<xs:complexType name="MemberMessageType">
	<xs:annotation>
		<xs:documentation>
			(in/out) Container for individual message information.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="MessageType" type="ns:MessageTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(in/out) The type of message being retrieved.
					For AddMemberMessage, any value besides ResponseToASQQuestion returns
					an error.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<CallName>AddMemberMessagesAAQToBidder</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="QuestionType" type="ns:QuestionTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(in/out) The context of the question (e.g. Shipping, General). Ignored input
					for AddMemberMessage.MessageType = ResponseToASQQuestion.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>AddMemberMessageAAQToPartner</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="EmailCopyToSender" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(in) Specifies whether or not to email a copy of the
					message to the sender. If omitted, this defaults to whatever
					the user set in preferences.
				</xs:documentation>
				<xs:appinfo>
					<Default>omitted</Default>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<CallName>AddMemberMessageAAQToPartner</CallName>
						<CallName>AddMemberMessageRTQ</CallName>
						<CallName>AddMemberMessagesAAQToBidder</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="HideSendersEmailAddress" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Specifies whether or not to hide sender's email address
					from the recipient. If omitted, this defaults to whatever
					the user set in preferences--or on site policy, which
					determines whether or not this field is recognized.
				</xs:documentation>
				<xs:appinfo>
					<Default>omitted</Default>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<CallName>AddMemberMessageAAQToPartner</CallName>
						<CallName>AddMemberMessageRTQ</CallName>
						<CallName>AddMemberMessagesAAQToBidder</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="DisplayToPublic" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(in/out) Specifies if the body should be displayed to the public. Ignored input
					for AddMemberMessage.MessageType = ResponseToASQQuestion.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SenderID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) The eBay user ID of the person who asked the question or sent
					the message.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SenderEmail" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The email address of the person who asked the question or sent
					the message. Returned by the AskSellerQuestion notification.
				</xs:documentation>
			</xs:annotation>
		</xs:element>
		<xs:element name="RecipientID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
			<xs:annotation>
				<xs:documentation>
					(in/out) Recipient's eBay user ID. For
					AddMemberMessagesAAQToBidder, must be the seller of an
					item, that item's bidder, or a user who has made an
					offer on that item via Best Offer.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<CallName>AddMemberMessageAAQToPartner</CallName>
						<CallName>AddMemberMessageRTQ</CallName>
						<CallName>AddMemberMessagesAAQToBidder</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Subject" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) Subject of this email message. Ignored input
					for AddMemberMessage.MessageType = ResponseToASQQuestion.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Body" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(in/out) Message content. Required input
					for AddMemberMessage.MessageType = ResponseToASQQuestion.
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>1000</MaxLength>
					<CallInfo>
						<CallName>AddMemberMessageAAQToPartner</CallName>
						<CallName>AddMemberMessageRTQ</CallName>
						<CallName>AddMemberMessagesAAQToBidder</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<RequiredInput>Conditionally</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="MessageID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(out) An ID that uniquely identifies a message for a given user.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMemberMessages</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ParentMessageID" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					(in) ID number of the question this message is responding to.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddMemberMessage</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>AddMemberMessageRTQ</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MerchDisplayCodeList.xsd #####

-->
	<xs:simpleType name="MerchDisplayCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies whether an eBay Stores seller prefers to promote items with a
			cross-promotion widget that is customized with the store theme or uses
			the default eBay theme. This option is the same as the one set on the
			seller's Customize Cross-Promotion Display page.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="DefaultTheme">
				<xs:annotation>
					<xs:documentation>
               		 (in/out) Uses the default eBay theme for cross-promotion widgets. 									</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoreTheme">
				<xs:annotation>
					<xs:documentation>
					(in/out) Uses the store theme for cross-promotion widgets.										</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                		(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MerchandizingPrefCodeList.xsd #####

-->
	<xs:simpleType name="MerchandizingPrefCodeType">
		<xs:annotation>
			<xs:documentation>
           MerchandizingPrefCodeType - Type declaration to be used by other
           schema. Indicates whether the seller has opted to participate in
           item cross-promotion through the Merchandising Manager feature. This
           option is set on the user's My eBay page and determines whether the
           seller's other items are cross-promoted with items from the seller
           that are listed or sold.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="OptIn">
				<xs:annotation>
					<xs:documentation>
                (in/out) Seller allows item cross-promotion.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OptOut">
				<xs:annotation>
					<xs:documentation>
                (in/out) Seller does not allow item cross-promotion.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MessageStatusTypeCodeList.xsd #####

-->
	<xs:simpleType name="MessageStatusTypeCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="Answered">
				<xs:annotation>
					<xs:documentation>
						The question has been answered at least once.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>	
			<xs:enumeration value="Unanswered">
				<xs:annotation>
					<xs:documentation>
						The question has not yet been answered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Not available.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MessageTypeCodeList.xsd #####

-->
	<xs:simpleType name="MessageTypeCodeType">
    <xs:restriction base="xs:token">
      <xs:enumeration value="AskSellerQuestion">
        <xs:annotation>
          <xs:documentation>
						Member to Member message initiated by bidder/potential bidder
						to a seller of a particular item.
					</xs:documentation>
        </xs:annotation>
      </xs:enumeration>
			<xs:enumeration value="ResponseToASQQuestion">
        <xs:annotation>
          <xs:documentation>
						Member to Member message initiated as a response
						to an Ask A Question message.
					</xs:documentation>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="ContactEbayMember">
        <xs:annotation>
          <xs:documentation>
						Member to Member message initiated by any eBay member
						to another eBay member.
					</xs:documentation>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="ContactTransactionPartner">
        <xs:annotation>
          <xs:documentation>
						Member message between transaction partners within 90 days
						after the transaction.
					</xs:documentation>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="CustomCode">
        <xs:annotation>
          <xs:documentation>
						Reserved for future or internal use.
					</xs:documentation>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MinimumReservePriceDefinitionType.xsd #####

-->
	<xs:complexType name="MinimumReservePriceDefinitionType">
		<xs:annotation>
			<xs:documentation>
				Defines the Minimum Reserve Price feature. If the field is present, the feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ModifiedFieldType.xsd #####

-->
	<xs:complexType name="ModifiedFieldType">
		<xs:annotation>
			<xs:documentation> 
				Identifies the fields that are being modified. Only applies when 
				revising and relisting items. To remove a property from an object,
				specify it in ModifiedFieldType, but do not specify a value in the
				object type (for example, ItemType).
				</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Field" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						The name of the field that is being modified. Use only first-level
						properties. The first letter of each node in the field is case insensitive, 
						so item.startPrice is the same as Item.StartPrice.
						In RelistItem, this is required if you are also modifying fields of the item 
						that you are relisting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>RelistItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseItem</CallName>
							<RequiredInput>Yes</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseLiveAuctionItem</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ModifyType" type="ns:ModifyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Instruction describing the nature of the modification. 
						In RelistItem, this is required if you are modifying fields of the item 
						that you are relisting.
						See the ModifyCodeList for valid values.
						</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>RelistItem</CallName>
								<RequiredInput>Conditionally</RequiredInput>
								<TagStatus>Deprecated</TagStatus>
							</CallInfo>
							<CallInfo>
								<CallName>ReviseItem</CallName>
								<RequiredInput>Yes</RequiredInput>
								<TagStatus>Deprecated</TagStatus>
							</CallInfo>
							<CallInfo>
								<CallName>ReviseLiveAuctionItem</CallName>
								<RequiredInput>Yes</RequiredInput>
							</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ModifyActionCodeList.xsd #####

-->
	<xs:simpleType name="ModifyActionCodeType">
		<xs:annotation>
			<xs:documentation>
          Specifies what action to take with the entry that is being modified.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Add">
				<xs:annotation>
					<xs:documentation>
						  (in) Add the entry
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delete">
				<xs:annotation>
					<xs:documentation>
						  (in) Delete the entry
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
				<xs:enumeration value="Update">
				<xs:annotation>
					<xs:documentation>
						  (in) Update the entry
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ModifyCodeList.xsd #####

-->
	<xs:simpleType name="ModifyCodeType">
		<xs:annotation>
			<xs:documentation>
           ModifyCodeType - Type declaration to be used by other schema. This
           code identifies the types of modifications that can be made to an object.
           For example, use this when changing or removing field values when
           re-listing an item.  
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Dropped">
				<xs:annotation>
					<xs:documentation>
                (in) Indicates that the value of the specified field should be removed.
				Do not use to remove a property from a listing with ReviseItem
				or RelistItem. See the Developer's Guide for details.
				Also applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ReviseItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Modify">
				<xs:annotation>
					<xs:documentation>
                (in) Indicates that the value of the specified field should be modified.
                Also applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>ReviseItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesAlertArrayType.xsd #####

-->
	<xs:complexType name="MyMessagesAlertArrayType">
		<xs:annotation>
			<xs:documentation>
				Contains a list of alert data.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Alert" type="ns:MyMessagesAlertType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Contains the data for one alert. Returned for
						detail levels ReturnHeaders and ReturnMessages.
						Parent returned as an empty node if user has no
						alerts.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesAlertIDArrayType.xsd #####

-->
	<xs:complexType name="MyMessagesAlertIDArrayType">
		<xs:annotation>
			<xs:documentation>
				Contains a list of up to 10 AlertID values.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AlertID" type="ns:MyMessagesAlertIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(in/out) An ID that uniquely identifies an alert for a given user. When AlertID values
						are used as input, you must generally specify either AlertID values, or MessageID values,
						or both.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>DeleteMyMessages</CallName>
							<CallName>GetMyMessages</CallName>
							<CallName>ReviseMyMessages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesAlertIDType.xsd #####

-->
	<xs:simpleType name="MyMessagesAlertIDType">
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesAlertResolutionStatusCodeList.xsd #####

-->
	<xs:simpleType name="MyMessagesAlertResolutionStatusCode">
		<xs:annotation>
			<xs:documentation>
				MyMessagesAlertResolutionStatusCode - Whether or not an alert was resolved, and how. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unresolved">
				<xs:annotation>
					<xs:documentation>
						The alert has not been resolved. If the alert requires user action, an unresolved status 
						means that the user did not take action on the alert. If the alert does not require user 
						action, an unresolved status means that the alert has not been read. Note that an 
						unresolved alert can not be deleted.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ResolvedByAutoResolution">
				<xs:annotation>
					<xs:documentation>
						The alert was resolved by auto resolution. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ResolvedByUser">
				<xs:annotation>
					<xs:documentation>
						The alert was resolved by user. If the alert requires user action, resolved status 
						means that the user took the necessary action on the alert. If the alert does not require user 
						action, resolved status means that the alert was read by the user. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesAlertType.xsd #####

-->
	<xs:complexType name="MyMessagesAlertType">
		<xs:annotation>
			<xs:documentation>
				(out) Returns an alert header and full alert
				information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Sender" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The display name of the eBay application that
						sends the alert.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RecipientUserID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The displayable user ID of the recipient.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Subject" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The subject of the alert.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Priority" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A number ranging from 0 to 10000 (inclusive),
						with 10000 having the highest priority.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AlertID" type="ns:MyMessagesAlertIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An ID that uniquely identifies an alert for a
						given user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalAlertID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An ID used by an external application to
						uniquely identify an alert.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ContentType" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The content type of the body text. The two
						acceptable values are "TEXT" and "HTML" (case
						sensitive).
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="Text" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The alert body. This can be either plain text
						or HTML, depending on which format the alert was
						originally written in. Note that the API does not
						currently check the user email format preferences
						that can be specified in My Messages on the eBay.com
						Web site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResolutionStatus" type="ns:MyMessagesAlertResolutionStatusCode" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Whether or not an alert was resolved, and how.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Read" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Whether or not an alert was viewed by a given
						user. Note that retrieving an alert with the API
						does not mark it as read.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreationDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time an alert was created by a sender.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="ReceiveDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time that an alert was received
						by My Messages and stored in a database for the
						recipient.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpirationDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time at which an alert expires.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResolutionDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time at which an alert is resolved.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="LastReadDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time an alert was last viewed by
						a given user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A unique eBay item ID associated with an
						alert.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IsTimedResolution" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates whether or not a time-delayed
						resolution is applicable for an alert.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ActionURL" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A URL that the recipient must visit to resolve
						an alert. May be returned as an empty tag if there is no applicable URL.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResponseDetails" type="ns:MyMessagesResponseDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Details relating to the response to an alert
						or message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ForwardDetails" type="ns:MyMessagesForwardDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Details relating to the forwarding of an alert
						or message.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="Folder" type="ns:MyMessagesFolderType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Details relating to a My Messages folder.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesFolderOperationCodeList.xsd #####

-->
	<xs:simpleType name="MyMessagesFolderOperationCodeType">
		<xs:annotation>
			<xs:documentation>
			MyMessagesFolderOperationCodeType - Indicates the type of
			operation to perform on a specified My Messsages folder.
			Operations cannot be performed on the Inbox or Sent folders.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Display">
				<xs:annotation>
					<xs:documentation>
						If a folder has been removed, restores the specified folder
						in My Messages. Because the Inbox and Sent folders cannot be
						removed, they can also not be restored. Requires FolderName
						as input.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Rename">
				<xs:annotation>
					<xs:documentation>
						Renames a specified folder. Inbox and Sent folders cannot be
						renamed. To rename a folder, use FolderID to indicate the
						folder to rename, and FolderName to indicate the new name.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Remove">
				<xs:annotation>
					<xs:documentation>
						Removes a specified folder. Inbox and Sent folders cannot be
						removed. Removing a folder that is not empty returns an
						error. Requires FolderID as input.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future or internal use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesFolderSummaryType.xsd #####

-->
	<xs:complexType name="MyMessagesFolderSummaryType">
		<xs:annotation>
			<xs:documentation>
				Summary details for a specified My Messages folder.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FolderID" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An ID that uniquely identifies a My Messages
						folder. Always returned for detail level
						ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FolderName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The name of a specified My Messages folder. For
						GetMyMessages, Inbox (FolderID = 0) and Sent (FolderID = 1)
						are not returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NewAlertCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of new alerts in a given folder.
						Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NewMessageCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of new messages in a given folder.
						Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalAlertCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The total number of alerts in a given folder.
						Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalMessageCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The total number of messages in a given
						folder. Always returned for detail level
						ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesFolderType.xsd #####

-->
	<xs:complexType name="MyMessagesFolderType">
		<xs:annotation>
			<xs:documentation>
				Details relating to a My Messages folder.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FolderID" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						An ID that uniquely identifies a My Messages folder.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<Context>Alerts</Context>
							<Context>Messages</Context>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FolderName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of a specified My Messages folder.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesForwardDetailsType.xsd #####

-->
	<xs:complexType name="MyMessagesForwardDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details relating to the forwarding of an alert or message.	
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserForwardDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time a user forwarded an alert or message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ForwardMessageEncoding" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Encoding used to forward an alert or message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesMessageArrayType.xsd #####

-->
	<xs:complexType name="MyMessagesMessageArrayType">
		<xs:annotation>
			<xs:documentation>
				Contains a list of message data.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Message" type="ns:MyMessagesMessageType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Contains the data for one message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesMessageIDArrayType.xsd #####

-->
	<xs:complexType name="MyMessagesMessageIDArrayType">
		<xs:annotation>
			<xs:documentation> 
				Contains a list of up to 10 MessageID values.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MessageID" type="ns:MyMessagesMessageIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(in/out) An ID that uniquely identifies a message for a given user. When MessageID values 
						are used as input, you must generally specify either AlertID values, or MessageID values, 
						or both.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>DeleteMyMessages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>ReviseMyMessages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesMessageIDType.xsd #####

-->
	<xs:simpleType name="MyMessagesMessageIDType">
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesMessageType.xsd #####

-->
	<xs:complexType name="MyMessagesMessageType">
		<xs:annotation>
			<xs:documentation>
				(out) Contains the message information for each message specified in
				MessageIDs. The amount and type of information returned varies based on
				the requested detail level.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Sender" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The display name of the eBay user that sent the message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RecipientUserID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The displayable user ID of the recipient.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SendToName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The displayable name of the user or eBay
						application to which the message is sent. Only
						returned for M2M, and if a value exists.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Subject" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The subject of the message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageID" type="ns:MyMessagesMessageIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An ID that uniquely identifies a message for a given user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalMessageID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) An ID used by an external application to uniquely identify
						a message.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="ContentType" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The content type of the body text. The three acceptable values
						are "TEXT", "HTML",  and "XML" (case sensitive).
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="Text" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The message body. This can be either plain
						text or HTML, depending on which format the message
						was originally written in. Note that the API does
						not currently check the user email format
						preferences that can be specified in My Messages on
						the eBay.com Web site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Flagged" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Whether or not a message has been flagged.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Read" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Whether or not a message has been viewed by a given user. Note that retrieving a message with the
						API does not mark it as read.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreationDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time that a message was created by the sender.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="ReceiveDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time that a message was received by My Messages and stored in a
						database for the recipient.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpirationDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The date and time at which a message expires.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) A unique eBay Item ID associated with a message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResponseDetails" type="ns:MyMessagesResponseDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Details relating to the response to an alert or message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ForwardDetails" type="ns:MyMessagesForwardDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Details relating to the forwarding of an alert or message.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:element name="Folder" type="ns:MyMessagesFolderType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Details relating to a My Messages folder.
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesResponseDetailsType.xsd #####

-->
	<xs:complexType name="MyMessagesResponseDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details relating to the response to an alert or message.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ResponseEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether or not an alert or message can be responded
						to. To respond to an alert or message, use the URL
						in ResponseURL. You may need to log into the eBay
						Web site to complete the response.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<Context>Alerts</Context>
							<Context>Messages</Context>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResponseURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A URL that the recipient must visit to respond to an
						alert or message. Responding may require logging
						into the eBay Web site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<Context>Alerts</Context>
							<DetailLevels>ReturnMessages</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<Context>Messages</Context>
							<DetailLevels>ReturnHeaders, ReturnMessages</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserResponseDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date and time the user responded to an alert or
						message
					</xs:documentation>
				<!-- N/A: GetMyMessages -->
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyMessagesSummaryType.xsd #####

-->
	<xs:complexType name="MyMessagesSummaryType">
		<xs:annotation>
			<xs:documentation>
				Summary data for a given user's alerts and messages.
				This includes the numbers of new alerts and messages,
				unresolved alerts, flagged messages, and total alerts
				and messages.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FolderSummary" type="ns:MyMessagesFolderSummaryType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Folder summary for each folder. Always
						returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NewAlertCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of new alerts that a given user
						has. Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NewMessageCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of new messages that a given user has. Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UnresolvedAlertCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of alerts that are not yet
						resolved. Always returned for detail level
						ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FlaggedMessageCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of messages that have been flagged.
						Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalAlertCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The total number of alerts for a given user.
						Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalMessageCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The total number of messages for a given user.
						Always returned for detail level ReturnSummary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyMessages</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnSummary</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyeBayFavoriteSearchListType.xsd #####

-->
	<xs:complexType name="MyeBayFavoriteSearchListType">
		<xs:annotation>
			<xs:documentation>
					A list of favorite searches a user has saved on the My eBay page.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TotalAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
								The total number of favorite searches saved.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FavoriteSearch" type="ns:MyeBayFavoriteSearchType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
								A favorite search the user has saved, with a name and a search query.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyeBayFavoriteSearchType.xsd #####

-->
	<xs:complexType name="MyeBayFavoriteSearchType">
		<xs:annotation>
			<xs:documentation>
        Characteristics of a saved My eBay Favorite Search.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SearchName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The name of the My eBay Favorite Search.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchQuery" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The query string of a My eBay Favorite Search.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
      <xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyeBayFavoriteSellerListType.xsd #####

-->
	<xs:complexType name="MyeBayFavoriteSellerListType">
		<xs:annotation>
			<xs:documentation>
					A list of favorite sellers the user has saved on the My eBay page.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TotalAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
 							The total number of favorite sellers saved. 
					</xs:documentation>
					<xs:appinfo>
						<Max>100</Max>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FavoriteSeller" type="ns:MyeBayFavoriteSellerType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
							A favorite seller the user has saved, with a user ID and store name.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyeBayFavoriteSellerType.xsd #####

-->
	<xs:complexType name="MyeBayFavoriteSellerType">
		<xs:annotation>
			<xs:documentation>
				 Characteristics of the My eBay Favorite Seller.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The favorite seller's eBay user ID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StoreName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The name of the store owned by the favorite seller, if applicable.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyeBaySecondChanceOfferListType.xsd #####

-->
	<xs:complexType name="MyeBaySecondChanceOfferListType">
		<xs:annotation>
			<xs:documentation> 
         A list of possible My eBay Second Chance Offers.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TotalAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The total number of My eBay Second Chance Offers available.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="SecondChanceOffer" type="ns:ItemType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            A Second Chance Offer item.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
      <xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/MyeBaySelectionType.xsd #####

-->
	<xs:complexType name="MyeBaySelectionType">
		<xs:annotation>
			<xs:documentation>
				Specifies how the result list for My eBay features such as favorite searches,
				favorite sellers, and second chance offers should be returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Include" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					 Specifies whether to include a container in the response.
					 Required if you do not specify any other tags to filter the
					 result list. If so, the list is returned according to
					 the default values. Ignored if you specify at least
					 one other tag for the result list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Sort" type="ns:SortOrderCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the result sort order. Default is Ascending.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxResults" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the maximum number of items in the returned list.
						If not specified, returns all items in the list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NameValueListArrayType.xsd #####

-->
	<xs:complexType name="NameValueListArrayType">
		<xs:annotation>
			<xs:documentation>
      A list of one or more valid names and corresponding values.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="NameValueList" type="ns:NameValueListType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					A name and corresponding value (a name/value pair).&lt;br&gt;
					&lt;br&gt;
					In the GetSearchResults response, this is only returned for applicable items 
					when the value of IncludeCondition was true in the GetSearchResults request,
					or when SearchRequest was used to perform a "Product Finder" search.&lt;br&gt;
					&lt;br&gt;
					In the GetSearchResultsExpress response, this is only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
							<!-- Separate appinfo due to detail levels. -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NameValueListType.xsd #####

-->
	<xs:complexType name="NameValueListType">
		<xs:annotation>
			<xs:documentation>
				A name and corresponding value (a name/value pair).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A name in a name/value pair.&lt;br&gt;
						&lt;br&gt;
						In the GetSearchResults response, this is an attribute name. Specifically:
						If SearchRequest was used to perform a "Product Finder" search, this contains the 
						name of one attribute (i.e, the name of one Item Specifics field).
						If IncludeCondition was true in the request, this returns the condition attribute name 
						(e.g., "Item Condition").&lt;br&gt;
						&lt;br&gt;
						In the GetSearchResultsExpress response, this is an attribute name.
						Only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
							<!-- Separate appinfo due to detail levels. -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Value" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The value in a name/value pair.&lt;br&gt;
						&lt;br&gt;
						In the GetSearchResults response, if SearchRequest was used to perform 
						a "Product Finder" search, this contains the
						value of one attribute (i.e., the value of one Item Specifics field).
						If IncludeCondition was true in the request, this returns the 
						condition attribute value (e.g., "New").&lt;br&gt;
						&lt;br&gt;
						In the GetSearchResultsExpress response, this is an attribute value.
						Only returned when ProductDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
							<!-- Separate appinfo due to detail levels. -->
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationDeliveryStatusCodeTypeList.xsd #####

-->
	<xs:simpleType name="NotificationDeliveryStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				Valid notification status codes
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future internal or external use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delivered">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was delivered
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Failed">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was failed
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Rejected">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was rejected
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarkedDown">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was marked down
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/NotificationDetailsArrayType.xsd #####

-->
	<xs:complexType name="NotificationDetailsArrayType">
		<xs:annotation>
			<xs:documentation> 
				Returns information about notifications sent to the given application
				for the given ItemID. It will only be returned if ItemID was specified in the
				input parameters.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="NotificationDetails" type="ns:NotificationDetailsType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
						(out) List of notifications, if there are any, for the given ItemID and given
						time period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationDetailsType.xsd #####

-->
	<xs:complexType name="NotificationDetailsType">
		<xs:annotation>
			<xs:documentation> 
				Information about a single notification. Notification information includes 
				the reference ID, notification type, current status, time delivered, error code, 
				and error message for the notification. If notification details are included in 
				the response, all of the detail fields are returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DeliveryURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Returns the destination address for the notification. This is the value set 
						using SetNotificationPreferences.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReferenceID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Reference identifier for the notification.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpirationTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Date and time when this notification will be removed from the 
						eBay system.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Type" type="ns:NotificationEventTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Returns the notification type. Possible values include: AskSellerQuestion, 
						AuctionCheckoutComplete, BestOffer, CheckoutBuyerRequestTotal, EndOfAuction, 
						Feedback, FixedPriceEndOfTransaction, FixedPriceTransaction, ItemNotReceived, 
						MyMessages, OutBid, SecondChanceOffer, UPIBuyerResponseDispute, UPISellerClosedDispute, 
						UPISellerOpenedDispute, and UPISellerRespondedToDispute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Retries" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Returns the total number of retries for the given notification.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeliveryStatus" type="ns:NotificationEventStateCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Returns the notification status. Possible values include Delivered, 
						Failed, Rejected, and MarkedDown. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NextRetryTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Returns the time when the notification is scheduled for retry. 
						This won't be included if the DeliveryStatus is Delivered.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeliveryTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Returns the time when the notification was delivered.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(out) Returns the error message.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationEnableArrayType.xsd #####

-->
	<xs:complexType name="NotificationEnableArrayType">
		<xs:annotation>
			<xs:documentation>
				(in/out) A list of NotificationEnable entries. Each entry specifies
				one notification and whether it is enabled.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="NotificationEnable" type="ns:NotificationEnableType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies one notification event and whether it is
						enabled or disabled. Returned if previously set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationEnableType.xsd #####

-->
	<xs:complexType name="NotificationEnableType">
		<xs:annotation>
			<xs:documentation>
				(in/out) Specifies a notification event and whether the
				notification is enabled or disabled.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EventType" type="ns:NotificationEventTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The name of the notification event.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="EventEnable" type="ns:EnableCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Whether the event is enabled or disabled.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationEventPropertyNameCodeList.xsd #####

-->
	<xs:simpleType name="NotificationEventPropertyNameCodeType">
		<xs:annotation>
			<xs:documentation>
				Defines all property names that can be used.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="TimeLeft">
				<xs:annotation>
					<xs:documentation>
						(in/out) Property name for WatchItemEndingSoon event, part of
						enabling a user to specify a time in minutes before the end
						of the listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/NotificationEventPropertyType.xsd #####

-->
	<xs:complexType name="NotificationEventPropertyType">
		<xs:annotation>
			<xs:documentation>
				(in/out) Defines properties associated with particular event.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EventType" type="ns:NotificationEventTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) The name of the notification event.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="ns:NotificationEventPropertyNameCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specify property name associated with an particular event.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Value" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies the value for the property.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationEventStateCodeList.xsd #####

-->
	<xs:simpleType name="NotificationEventStateCodeType">
		<xs:annotation>
			<xs:documentation>
				Valid notification status codes
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="New">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification is newly created
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Failed">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was failed
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarkedDown">
				<xs:annotation>
					<xs:documentation>
						Status indicating the end user application is marked down
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification is pending
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FailedPending">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification is failed pending
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarkedDownPending">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification is marked down pending
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delivered">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was successfully delivered
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Undeliverable">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was unable to deliver
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Rejected">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was rejected
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Canceled">
				<xs:annotation>
					<xs:documentation>
						Status indicating the notification was cancelled
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future internal or external use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/NotificationEventTypeCodeList.xsd #####

-->
	<xs:simpleType name="NotificationEventTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			    Defines all notification events that can be used.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
					  (out)	Not a notification event.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OutBid">
				<xs:annotation>
					<xs:documentation>
						(in/out)	Sent to a user when another buyer has placed a higher maximum bid
						and the user is no longer the current high bidder.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EndOfAuction">
				<xs:annotation>
					<xs:documentation>
						(in/out)	Sent when an auction ends. An auction ends either when its duration
						expires, the buyer purchases an item with Buy It Now, or the auction is
						canceled. Applies to both Chinese and Dutch auctions.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AuctionCheckoutComplete">
				<xs:annotation>
					<xs:documentation>
						(in/out)	Sent to a seller when a buyer completes the checkout process for an
						item. Occurs even when a seller has disabled checkout and the buyer uses
						eBayPayments.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPriceEndOfTransaction">
				<xs:annotation>
					<xs:documentation>
						(in/out)	Sent to a seller when a fixed-price item is sold and the buyer
						completes the checkout process. Not sent when a fixed-price item's duration
						expires without purchase.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CheckoutBuyerRequestsTotal">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to a seller each time a buyer requests a total price. Occurs
						before checkout is complete.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Feedback">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to a partner when a buyer leaves a feedback entry for a seller
						or when the seller responds.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FeedbackForSeller">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to a partner when a buyer leaves a feedback entry for a seller
						or when the seller responds. This tag is to be phased out. It is used here
						only for backward compatibility.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FixedPriceTransaction">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to a user when a listing for a fixed price item ends. A fixed
						price listing ends when a buyer starts to move through checkout or purchases
						the item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SecondChanceOffer">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AskSellerQuestion">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to a seller when a question is posted about one of the seller's
						active listings.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemListed">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to an eBay partner on behalf of a seller when a seller has
						listed an item. Sent for each item the seller lists.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemRevised">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies an ItemRevised notification event.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerResponseDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to an eBay partner on behalf of a seller when a buyer responds
						to a dispute the seller has opened. Sent for each response the buyer makes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerOpenedDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to an eBay partner on behalf of a seller when a seller opens a
						dispute. Sent for each dispute the seller opens.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerRespondedToDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to an eBay partner on behalf of a seller when a seller responds
						to a dispute they had opened. Sent for each response the seller makes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerClosedDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to an eBay partner on behalf of a seller when a seller closes a
						dispute they had opened. Sent for each closure the seller performs.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestOffer">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sent to a seller when a bidder makes a best offer on an item opted
						into the Best Offer feature by the seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyMessagesAlertHeader">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is notified
						when an alert is sent to My Messages. This notification type sends a
						GetMyMessages response at a detail level of ReturnHeaders.
						MyMessagesAlertHeader and MyMessagesAlert cannot be subscribed to at the same
						time or specified in the same call.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyMessagesAlert">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified when an alert is sent to My Messages. This notification type sends
						a GetMyMessages response at a detail level of ReturnMessages.
						MyMessagesAlertHeader and MyMessagesAlert cannot be subscribed to at the
						same time or specified in the same call.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyMessageseBayMessageHeader">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified when a message from eBay is sent to My Messages. This notification
						type sends a GetMyMessages response at a detail level of ReturnHeaders.
						MyMessageseBayMessageHeader and MyMessageseBayMessage cannot be subscribed
						to at the same time or specified in the same call.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyMessageseBayMessage">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified when a message from eBay is sent to My Messages. This notification
						type sends a GetMyMessages response at a detail level of ReturnMessages.
						MyMessageseBayMessageHeader and MyMessageseBayMessage cannot be subscribed
						to at the same time or specified in the same call.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyMessagesM2MMessageHeader">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified when a member to member (M2M) message is sent to My Messages. This
						notification type sends a GetMyMessages response at a detail level of
						ReturnHeaders. MyMessagesM2MMessageHeader and MyMessagesM2MMessage cannot
						be subscribed to at the same time or specified in the same call.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyMessagesM2MMessage">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified when a member to member (M2M) message is sent to My Messages. This
						notification type sends a GetMyMessages response at a detail level of
						ReturnMessages. MyMessagesM2MMessageHeader and MyMessagesM2MMessage cannot
						be subscribed to at the same time or specified in the same call.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="INRBuyerOpenedDispute">
				<xs:annotation>
					<xs:documentation>
					  (in/out) A notification type where a specified user or application is
						notified on behalf of a buyer when a buyer opens an Item Not Received dispute.
						Sent for each dispute the buyer opens.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="INRBuyerRespondedToDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified on behalf of a buyer when a buyer responds to Item Not Received
						dispute that buyer had opened. Sent for each response the buyer makes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="INRBuyerClosedDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where a specified user or application is
						notified on behalf of a buyer when a buyer closes Item Not Received
						dispute that buyer had opened. Sent for each closure the buyer performs.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="INRSellerRespondedToDispute">
				<xs:annotation>
					<xs:documentation>
						(in/out)  A notification type where a specified user or application is
						notified on behalf of a seller when a seller responds to an Item Not Received
						dispute that buyer had opened. Sent for each response the seller makes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Checkout">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where an application is notified
						that checkout has been handled by eBay Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WatchedItemEndingSoon">
				<xs:annotation>
					<xs:documentation>
						(in/out) A notification type where the listing of the watched item is about to
						end. This event has a property with which caller can specify the TimeLeft
						before the listing ends.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemClosed">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemSuspended">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemSold">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemExtended">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UserIDChanged">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EmailAddressChanged">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PasswordChanged">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PasswordHintChanged">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentDetailChanged">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountSuspended">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountSummary">
				<xs:annotation>
					<xs:documentation>
						(in/out) An informational alert about account activity. It is not
						triggered by an event but rather by an eBay daemon process that
						monitors a schedule database.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					  (out)	Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/NotificationMessageType.xsd #####

-->
		<xs:element name="NotificationMessage" type="ns:NotificationMessageType"/>
<xs:complexType name="NotificationMessageType">
		<xs:annotation>
			<xs:documentation>
				(out) A template for an SMS notification message.
			</xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:extension base="ns:AbstractResponseType">
				<xs:sequence>
					<xs:element name="MessageBody" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) The SMS message.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<NoCalls/>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
					<xs:element name="EIAS" type="xs:string" minOccurs="0">
						<xs:annotation>
							<xs:documentation>
								(out) The EIAS userId.
							</xs:documentation>
							<xs:appinfo>
								<CallInfo>
									<NoCalls/>
									<Returned>Conditionally</Returned>
								</CallInfo>
							</xs:appinfo>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationPayloadTypeCodeList.xsd #####

-->
	<xs:simpleType name="NotificationPayloadTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				The schema options for Platform Notifications.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="eBLSchemaSOAP">
				<xs:annotation>
					<xs:documentation>
						(in/out) New Schema format (used by the new schema XML API and SOAP API).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/NotificationRoleCodeList.xsd #####

-->
	<xs:simpleType name="NotificationRoleCodeType">
		<xs:annotation>
			<xs:documentation>
				Defines roles for platform notifications.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Application">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies that you want to set or return application-level
						preferences. Default value.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="User">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies that you want to set or return user-level preferences.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UserData">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies that you want to set or return user data-level preferences.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Event">
				<xs:annotation>
					<xs:documentation>
						(in/out) Specifies that you want to set or return event-level preferences.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/NotificationStatisticsType.xsd #####

-->
	<xs:complexType name="NotificationStatisticsType">
		<xs:annotation>
			<xs:documentation> 
				Summary information about notifications delivered, failed, errors, queued for 
				a given application ID and time period.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DeliveredCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns the number of notifications delivered successfully during the given 
						time period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QueuedNewCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns the number of new notifications that were queued during 
						the given time period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QueuedPendingCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns the number of pending notifications in the queue during 
						the given time period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpiredCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns the number of notifications that permanently failed during 
						the given time period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Returns the number of notifications for which there were delivery errors 
						during the given time period.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetNotificationsUsage</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/NotificationUserDataType.xsd #####

-->
	<xs:complexType name="NotificationUserDataType">
		<xs:annotation>
			<xs:documentation>
				User data related to notifications.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SMSSubscription" type="ns:SMSSubscriptionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						User data related to SMS notifications.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SummarySchedule" type="ns:SummaryEventScheduleType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						User account activity summary alert delivery schedule.
						Returned if PreferenceLevel is set to UserData in
						GetNotificationPreferences.
						See "Working with Platform Notifications" for instructions on
						"Informational Alerts".
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OfferArrayType.xsd #####

-->
	<xs:complexType name="OfferArrayType">
		<xs:annotation>
			<xs:documentation> 
        Container for a list of offers. May contain zero, one, or multiple
        OfferType objects, each of which represents one offer extended by
        a user on a listing.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Offer" type="ns:OfferType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Contains the data for one offer. This includes: data for the user making the
            offer, the amount of the offer, the quantity of items being bought from the
            listing, the type of offer being made, and more.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetAllBidders</CallName>
								<CallName>GetHighBidders</CallName>
								<Returned>Conditionally</Returned>
							</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OfferType.xsd #####

-->
	<xs:complexType name="OfferType">
		<xs:annotation>
			<xs:documentation>
				Contains information pertaining to an offer made on an item listing and
				the current bidding or purchase state of the listing.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Action" type="ns:BidActionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the type of offer being made on the specified listing. Valid
						values are enumerated in the BidActionCodeType code list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Numeric ID for the currency for the auction. Valid values are
						enumerated in the CurrencyCodeType code list.
					</xs:documentation>
					<xs:appinfo>
						<!-- N/A to PlaceOffer -->
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The unique identifier of an item listed on the eBay site.
						Returned by eBay when the item is created.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxBid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount of the offer placed. For competitive-bidding listings, the amount
						bid on the item (subject to outbid by other buyers). For fixed-price
						listings, the fixed sale price at which the item is purchased. For
						competitive-bidding listings with an active Buy It Now option, this amount
						will be either the Buy It Now price for purchase or the amount of a bid,
						depending on the offer type (as specified in Action). For PlaceOffer,
						the currencyID attribute is ignored if provided.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Quantity" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the number of items from the specified listing the user
						tendering the offer intends to purchase or bid on. For Chinese auctions and
						other listing formats that only allow one item per listing, value may not
						exceed one. For multi-item listings, must be greater than zero and not
						exceeding the number of items offered for sale in the listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SecondChanceEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the user's preference to accept second chance offers. If true,
						the user is willing to be the recipient of second chance offers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteCurrency" type="ns:CurrencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique ID identifying the currency in which the localized offer amounts are
						expressed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TimeBid" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date and time the offer or bid was placed.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetAllBidders</CallName>
								<CallName>GetHighBidders</CallName>
								<Returned>Always</Returned>
							</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HighestBid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount the highest bidder had bid on the item. Applicable only to
						competitive-bidding listings (Chinese and Dutch auctions) where there is
						progressive bidding and winning bidders are determined based on the highest
						bid.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Localized amount for the item's current price.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
  						<CallName>GetHighBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The unique identifier of the transaction. The transaction
						is created when a winning bidder commits to purchasing an
						item, even before the bidder has paid.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="User" type="ns:UserType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Bidder information. See the schema documentation for UserType for details
						on its properties and their meanings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserConsent" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, confirms that the bidder read and agrees to eBay's
						privacy policy. Applies if the subject item is in a category
						that requires user consent. If user consent (that is,
						confirmation that a bidder read and agrees to eBay's privacy
						policy) is required for a category that the subject item is in,
						this value must be true for a bid to occur.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OperationTypeCodeList.xsd #####

-->
	<xs:simpleType name="OperationTypeCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies whether the rules being defined are item rules
			or default rules. A new item rule is created if no rule exists with 
			the same scheme; otherwise, it replaces one existing item rule.
			A new default rule replaces the entire set of rules for that promotion method.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ItemRules">
				<xs:annotation>
					<xs:documentation>
					Use when setting item-specific rules.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReplaceAllDefaultRules">
				<xs:annotation>
					<xs:documentation>
					Use when setting default rules.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/OrderArrayType.xsd #####

-->
	<xs:complexType name="OrderArrayType">
	<xs:annotation>
		<xs:documentation>
			An array of Orders.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="Order" type="ns:OrderType" minOccurs="0" maxOccurs="unbounded">
		<xs:annotation>
			<xs:documentation>
				Also applicable to Half.com.
			</xs:documentation>
			<xs:appinfo>
				<CallInfo>
					<CallName>GetOrders</CallName>
					<Returned>Always</Returned>
				</CallInfo>
				<CallInfo>
					<CallName>GetOrderTransactions</CallName>
					<DetailLevels>none</DetailLevels>
					<Returned>Always</Returned>
				</CallInfo>
			</xs:appinfo>
		</xs:annotation>
		</xs:element>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OrderIDArrayType.xsd #####

-->
	<xs:complexType name="OrderIDArrayType">
		<xs:annotation>
			<xs:documentation>
				A list of unique identifiers for orders.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="OrderID" type="ns:OrderIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A unique identifier for an order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<CallName>GetOrderTransactions</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OrderIDType.xsd #####

-->
	<xs:simpleType name="OrderIDType">
		<xs:annotation>
			<xs:documentation>
				A unique identifier for an order.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/OrderRoleCodeList.xsd #####

-->
	<xs:simpleType name="OrderRoleCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="Buyer">
			</xs:enumeration>
			<xs:enumeration value="Seller">
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/OrderStatusCodeList.xsd #####

-->
	<xs:simpleType name="OrderStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				The set of valid states for an order.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
						(out) Active order status.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Inactive">
				<xs:annotation>
					<xs:documentation>
						(out) Inactive order status.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Completed">
				<xs:annotation>
					<xs:documentation>
						(out) Completed order status.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Cancelled">
				<xs:annotation>
					<xs:documentation>
						(out) Cancelled order status.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/OrderTransactionArrayType.xsd #####

-->
	<xs:complexType name="OrderTransactionArrayType">
		<xs:annotation>
			<xs:documentation>
						Contains a list of orders, transactions, or both, each of OrderTransactionType.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="OrderTransaction" type="ns:OrderTransactionType"  minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
								The individual order or transaction.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OrderTransactionType.xsd #####

-->
	<xs:complexType name="OrderTransactionType">
		<xs:annotation>
			<xs:documentation>
					Contains an order or a transaction. A transaction is the sale of one or
					more items from a seller's listing to a buyer. An order combines two or more transactions
					into a single payment.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Order" type="ns:OrderType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							Contains the information describing an order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Transaction" type="ns:TransactionType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							Contains the information describing a transaction.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/OrderType.xsd #####

-->
	<xs:complexType name="OrderType">
		<xs:annotation>
			<xs:documentation>
				A combination of two or more transactions that can be paid for with a
				single payment.&lt;br&gt;
				&lt;br&gt;
				We strongly recommend that you avoid mixing digital and non-digital listings in
				the same order. (In the future, AddOrder may enforce this recommendation.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="OrderID" type="ns:OrderIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for the order.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="OrderStatus" type="ns:OrderStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The current status of the order.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AdjustmentAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount by which the buyer is adjusting the order total. Used when
						the seller has not supplied payment details such as shipping and
						handling or insurance fee.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AmountPaid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount the buyer has paid the seller for the order.
						For GetOrders, applies only to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AmountSaved" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount the buyer saved by having multiple items combined into
						a single order, versus purchasing the items separately.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CheckoutStatus" type="ns:CheckoutStatusType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The current checkout status of the order.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingDetails" type="ns:ShippingDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The shipping-related details for an item or transaction,
						including flat or calculated shipping costs and shipping
						insurance costs.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreatingUserRole" type="ns:TradingRoleCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the order is created by the buyer or by the seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreatedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date and time the order was created.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FinanceOfferID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies a promotional offer that allow the buyer to purchase items on credit.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentMethods" type="ns:BuyerPaymentMethodCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
	    		  The payment methods the buyer uses to pay for
	    		  the order. An order can have multiple payment methods if the
	    		  buyer combines several transactions into one order.
	    		  Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerEmail" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The email of the order's seller.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingAddress" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Shipping address the order has been or will be sent to.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceSelected" type="ns:ShippingServiceOptionsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The shipping service selected by the buyer from the services
						offered by the seller.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Subtotal" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The sum of the sale prices of all of the transactions in the order, where
						a transaction sale price is the item sale price times the quantity sold.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Total" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Subtotal plus the shipping cost plus the sales tax plus cost of insurance.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalTransaction" type="ns:ExternalTransactionType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Not applicable to Half.com.
						A PayPal transaction that relates to this eBay transaction.
						Returned only if there is at least one PayPal transaction related to this
						eBay transaction.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DigitalDelivery" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the order contains at least one transaction for a digital listing.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionArray" type="ns:TransactionArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The set of two or more transactions that make up the order.
						Also applicable to Half.com (for GetOrders).&lt;br&gt;
						&lt;br&gt;
						We strongly recommend that you avoid mixing transactions for digital and non-digital listings in the same order.
						(In the future, AddOrder may enforce this recommendation.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerUserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						User ID of the order's buyer.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaginatedItemArrayType.xsd #####

-->
	<xs:complexType name="PaginatedItemArrayType">
		<xs:annotation>
			<xs:documentation>
				Contains a paginated list of items.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemArray" type="ns:ItemArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains a list of Item types.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>BestOfferList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Provides information about the list, including number of pages and number
						of entries.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaginatedOrderTransactionArrayType.xsd #####

-->
	<xs:complexType name="PaginatedOrderTransactionArrayType">
		<xs:annotation>
			<xs:documentation>
			Contains a paginated list of orders, transactions, or both, with each
			item an OrderTransactionType.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="OrderTransactionArray" type="ns:OrderTransactionArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Contains the list of orders, transactions, or both.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies information about the list, including number of pages and
						number of entries.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaginatedTransactionArrayType.xsd #####

-->
	<xs:complexType name="PaginatedTransactionArrayType">
		<xs:annotation>
			<xs:documentation>
				(out) Contains a paginated list of transactions.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TransactionArray" type="ns:TransactionArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Contains a list of transactions. Returned as an
						empty tag if no applicable transactions exist.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaginationResult" type="ns:PaginationResultType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Provides information about the list of transactions,
						including number of pages and number of entries.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaginationResultType.xsd #####

-->
	<xs:complexType name="PaginationResultType">
		<xs:annotation>
			<xs:documentation>
				(out) Shows the pagination of data returned by requests.
				Pagination of returned data is not needed in and not
				supported for every call. See the documentation for
				individual calls to determine whether pagination is
				supported, required, or desirable.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TotalNumberOfPages" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates the total number of pages of data
						that could be returned by repeated requests. For
						GetOrders, not applicable to eBay.com (for
						GetOrders, applicable to Half.com). Returned with a
						value of 0 if no pages are available.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAccount</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSellerPayments</CallName>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetUserDisputes</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnSummary, ReturnAll, none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetPopularKeywords</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>BestOfferList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalNumberOfEntries" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates the total number of entries that
						could be returned by repeated requests. For
						GetOrders, not applicable to eBay.com (for
						GetOrders, applicable to Half.com). Returned with a
						value of 0 if no entries are available.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetLiveAuctionBidders</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetSellerPayments</CallName>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetLiveAuctionBidders</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetPopularKeywords</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>BestOfferList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaidStatusCodeList.xsd #####

-->
	<xs:simpleType name="PaidStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			Specifies the payment status of a transaction, as
			seen by the buyer and seller.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NotPaid">
				<xs:annotation>
					<xs:documentation>
						The buyer has not completed checkout, but has not paid through PayPal or
						PaisaPay. The buyer might have paid using another method, but the payment
						might not have been received or cleared.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerHasNotCompletedCheckout">
				<xs:annotation>
					<xs:documentation>
						The buyer has not completed the checkout process and so has not made payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentPendingWithPayPal">
				<xs:annotation>
					<xs:documentation>
						The buyer has made a PayPal payment, but the seller has not yet received it.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaidWithPayPal">
				<xs:annotation>
					<xs:documentation>
						The buyer has made a PayPal payment, and the payment is complete.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MarkedAsPaid">
				<xs:annotation>
					<xs:documentation>
						The transaction is marked as paid by either buyer or seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentPendingWithEscrow">
				<xs:annotation>
					<xs:documentation>
						The buyer has made an escrow payment, but the seller has not yet received it.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaidWithEscrow">
				<xs:annotation>
					<xs:documentation>
						The buyer has made an escrow payment, and the seller has received payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EscrowPaymentCancelled">
				<xs:annotation>
					<xs:documentation>
						The buyer has made an escrow payment, but has cancelled the payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentPendingWithPaisaPay">
				<xs:annotation>
					<xs:documentation>
						The buyer has paid with PaisaPay, but the payment is still being processed.
						The seller has not yet received payment.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaidWithPaisaPay">
				<xs:annotation>
					<xs:documentation>
						The buyer has paid with PaisaPay, and the payment is complete.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaymentPending">
				<xs:annotation>
					<xs:documentation>
						The buyer has made a payment other than PayPal, escrow, or PaisaPay, but the
						payment is still being processed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PayPalAccountLevelCodeList.xsd #####

-->
	<xs:simpleType name="PayPalAccountLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				PayPal account level.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unverified">
				<xs:annotation>
					<xs:documentation>
						Account unverified
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InternationalUnverified">
				<xs:annotation>
					<xs:documentation>
						Account international unverified
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Verified">
				<xs:annotation>
					<xs:documentation>
						Account verified
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InternationalVerified">
				<xs:annotation>
					<xs:documentation>
						Account international verified
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Trusted">
				<xs:annotation>
					<xs:documentation>
						Account trusted
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Unknown"/>
			<xs:enumeration value="Invalid"/>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						 Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PayPalAccountStatusCodeList.xsd #####

-->
	<xs:simpleType name="PayPalAccountStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				PayPal account status.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
						Account is active.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Closed">
				<xs:annotation>
					<xs:documentation>
						Account is closed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HighRestricted">
				<xs:annotation>
					<xs:documentation>
						Account is highly restricted.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LowRestricted">
				<xs:annotation>
					<xs:documentation>
						Account restriction is low.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Locked">
				<xs:annotation>
					<xs:documentation>
						Account is locked.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WireOff"/>
			<xs:enumeration value="Unknown"/>
			<xs:enumeration value="Invalid"/>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PayPalAccountTypeCodeList.xsd #####

-->
	<xs:simpleType name="PayPalAccountTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				PayPal account type.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Personal">
				<xs:annotation>
					<xs:documentation>
						Personal account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Premier">
				<xs:annotation>
					<xs:documentation>
						Premier account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Business">
				<xs:annotation>
					<xs:documentation>
						Business account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Unknown"/>
			<xs:enumeration value="Invalid"/>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						 Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PaymentDetailsType.xsd #####

-->
	<xs:complexType name="PaymentDetailsType">
		<xs:annotation>
			<xs:documentation> 
			Data associated with payment (payment durations).
		</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="HoursToDeposit" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
				Applies to US eBay Motors site (except Parts and Accessories category).
				Number of hours after a listing closes that the buyer can put down a deposit
				on an item. The choices are 24, 48, and 72, and the default is 48.  
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>GetItemRecommendations</CallName>
						  <CallName>RelistItem</CallName>
						  <CallName>ReviseItem</CallName>
						  <CallName>VerifyAddItem</CallName>
						  <RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetBidderList</CallName>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DaysToFullPayment" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
				Applies to US eBay Motors site (except Parts and Accessories category) and eBay Canada site for motors.
				Number of days after a listing closes that the buyer can take to pay for the item. 
				The choices are 3, 7, 10, and 14, and the default is 7.  
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
						  <CallName>AddItem</CallName>
						  <CallName>GetItemRecommendations</CallName>
						  <CallName>RelistItem</CallName>
						  <CallName>ReviseItem</CallName>
						  <CallName>VerifyAddItem</CallName>
						  <RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
						  <CallName>GetBidderList</CallName>
						  <CallName>GetItem</CallName>
						  <Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaymentMethodSearchCodeType.xsd #####

-->
	<xs:simpleType name="PaymentMethodSearchCodeType">
		<xs:annotation>
			<xs:documentation>
				Used for specifying items for which a specific payment method or methods are accepted. 
   		</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="PayPal">
				<xs:annotation>
					<xs:documentation>
					  PayPal payment method.
				  </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PaisaPay">
				<xs:annotation>
					<xs:documentation> 
					  PaisaPay payment method. The PaisaPay payment method is only for the India site (site ID 203).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalOrPaisaPay">
				<xs:annotation>
					<xs:documentation>
					  Either the PayPal or the PaisaPay payment method. The PaisaPay payment method is only for the India site (site ID 203).
					 </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PaymentOptionDetailsType.xsd #####

-->
	<xs:complexType name="PaymentOptionDetailsType">
		<xs:annotation>
			<xs:documentation> 
				Details about a specific payment option.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PaymentOption" type="ns:BuyerPaymentMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						A payment method value defined in the schema.&lt;br&gt;&lt;br&gt;
						Related fields:&lt;br&gt;
						Item.PaymentMethods in AddItem&lt;br&gt;
						PaymentMethodUsed in ReviseCheckoutStatus
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Full name of the payment method for display purposes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PaymentStatusCodeList.xsd #####

-->
	<xs:simpleType name="PaymentStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			Indicates the success or failure of the buyer's online 
			payment for a transaction.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NoPaymentFailure">
				<xs:annotation>
					<xs:documentation>
						    (out) No payment failure.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerECheckBounced">
				<xs:annotation>
					<xs:documentation>
						    (out) The buyer's eCheck bounced.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerCreditCardFailed">
				<xs:annotation>
					<xs:documentation>
						   (out) The buyer's credit card failed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerFailedPaymentReportedBySeller">
				<xs:annotation>
					<xs:documentation>
						  (out) The seller reports that the buyer's payment
						  failed. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalPaymentInProcess">
				<xs:annotation>
					<xs:documentation>
						  (out) The payment from buyer to seller is in PayPal process, 
                           but has not yet been completed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PaymentTypeCodeList.xsd #####

-->
	<xs:simpleType name="PaymentTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				For GetSellerPayments, indicates the type of Half.com payment being
				made (sale or refund).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Sale">
				<xs:annotation>
					<xs:documentation>
						(in) The buyer paid the seller.
						Also applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Refund">
				<xs:annotation>
					<xs:documentation>
						(in) The seller issued a refund to the buyer.
						Also applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SellerDeniedPayment">
				<xs:annotation>
					<xs:documentation>
						For eBay internal use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AdminReversal">
				<xs:annotation>
					<xs:documentation>
						For eBay internal use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AllOther">
				<xs:annotation>
					<xs:documentation>
						All other payment types.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PhotoDisplayCodeList.xsd #####

-->
	<xs:simpleType name="PhotoDisplayCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies the type of image display used in a listing. Some options are
				only available if images are hosted through eBay Picture Services (EPS).
				Cannot be used with Listing Designer layouts (specified in Item.ListingDesigner).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(in/out) No special image display options. Valid for US Motors listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SlideShow">
				<xs:annotation>
					<xs:documentation>
						(in/out) Display multiple pictures in a slideshow format. Only available for
						site-hosted pictures. Deprecated with a compatibility level of 381. Use
						SiteHostedPictureShow or VendorHostedPictureShow instead. Not valid
						for US Motors listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SuperSize">
				<xs:annotation>
					<xs:documentation>
							 (in/out) Increase the size of each image and allow buyers to enlarge images
							 further. Only available for site-hosted images. Not valid for US Motors listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PicturePack">
				<xs:annotation>
					<xs:documentation>
							(in/out) Increase the number of images displayed. Only available for site-hosted images.
							Valid for US Motors listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SiteHostedPictureShow">
				<xs:annotation>
					<xs:documentation>
							(in/out) Display multiple, site-hosted pictures in a slideshow format.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VendorHostedPictureShow">
				<xs:annotation>
					<xs:documentation>
							(in/out) Display multiple, vendor-hosted pictures in a slideshow format.
							 Not valid for US Motors listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SuperSizePictureShow">
				<xs:annotation>
					<xs:documentation>
							(in/out) Display multiple, super-size, site-hosted pictures in a slideshow format.
							Valid for US Motors listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetMyeBayBuying</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
							(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PictureDetailsType.xsd #####

-->
	<xs:complexType name="PictureDetailsType">
		<xs:annotation>
			<xs:documentation>
				Contains the data for a picture associated with an item.
				Replaces the deprecated SiteHostedPicture and
				VendorHostedPicture in the response with compatibility level 439
				or greater. With the future deprecation of SiteHostedPicture and
				VendorHostedPicture as input, applications should use
				PictureDetails in the input instead.
		Not applicable to Half.com.
		</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="GalleryType" type="ns:GalleryTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether listing images are included in the search
						results (in both Picture Gallery and List Views) and, if so,
						which image listing enhancements apply to them. Items that
						have pictures but do not have image listing enhancements
						display a generic photo image in search results.
						&lt;br&gt;&lt;br&gt;
						If the value is Gallery, Plus, or Featured, eBay checks the
						available image URLs in the following order to determine
						which URL to use (if more than one of these URLs is
						available):
						&lt;br&gt;&lt;br&gt;
            a) Use the URL in GalleryURL, if it is specified.&lt;br&gt;
						b) Otherwise, if
						ProductListingDetails.UseStockPhotoURLAsGallery is true, use
						the eBay stock photo.&lt;br&gt;
						c) Otherwise, use the value of the first PictureURL in the
						array of PictureURL fields, if any.&lt;br&gt;
						d) Otherwise, if ProductListingDetails.ProductID is
						specified, use the eBay stock photo for that ProductID
								(eBay resets UseStockPhotoURLAsGallery to true in this
								case).&lt;br&gt;
						e) If eBay is unable to find an image URL for the listing,
						an error is returned.
						&lt;br&gt;&lt;br&gt;
						Note that the Gallery Plus feature requires that the image
						be hosted with the eBay Picture Service (EPS). One EPS image
						is included at no cost with the Gallery Plus feature.
						&lt;br&gt;&lt;br&gt;
						See "Describing Items in a Listing" in the eBay Web Services
						Guide for additional information about working with pictures and related validation rules.
						&lt;br&gt;&lt;br&gt;
						You cannot remove Gallery, Plus, or Featured when revising or relisting, however you can upgrade to a higher feature. On upgrade, the original feature fee is credited, and the new feature fee is charged.
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<SeeLink>
							<Title>Describing Items in a Listing</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=DescribingItems</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GalleryURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						URL for a picture to be used as the Gallery thumbnail. Ignored if
						GalleryType is None or unspecified. If the value of GalleryType is
						Gallery or Featured, you can either specify GalleryURL or allow eBay
						to use another picture that you have included in the listing. (See
						GalleryType for the rules that determine which URL is used if you do
						not specify GalleryURL.) The image used for the Gallery thumbnail
						must be in one of the graphics formats JPEG, BMP, TIF, or GIF. See
						"Describing Items in a Listing" in the eBay Web Services Guide for
						additional validation rules. For eBay Live Auctions, lots are listed
						in the gallery for free. To remove GalleryURL when revising or
						relisting an item, use DeletedField. When you revise an item, you
						can only remove GalleryURL if the item has at least one PictureURL
						or a stock photo to use instead. If the item has bids (or items have
						been sold) or the listing ends within 12 hours, you can add
						GalleryURL or change its value, but you cannot remove the gallery
						URL value if it was previously specified. Not applicable to eBay
						Motors listings.
						If the value of GalleryType is Gallery or Plus or Featured,
				</xs:documentation>
					<xs:appinfo>
						<MaxLength>1024</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PhotoDisplay" type="ns:PhotoDisplayCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Specifies the type of image display used in a listing. Some options are
					only available if images are hosted through eBay Picture Services (EPS).
					eBay determines this by parsing the associated PictureURL.
					Cannot be used in combination with Listing Designer layouts.
					Specify None or do not add PhotoDisplay when ListingDesigner.LayoutID
					is a value other than 0.
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PictureURL" type="xs:anyURI" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Contains the URL for an image associated with the item. Images can
						be hosted by eBay Picture Services (EPS) (or by eBay Picture
						Manager) or they can be self-hosted. Some options are only available
						if images are hosted through eBay Picture Services (EPS). eBay
						determines this by parsing the associated PictureURL value. If
						specified, this cannot have an empty/null value.&lt;br&gt;&lt;br&gt;
						To specify multiple pictures, send each URL in a separate, adjacent
						PictureURL element. In most cases, the image at the first URL is
						also used for the picture at the top of the View Item page on the
						Web site.&lt;br&gt;&lt;br&gt;
						On the main eBay site, a listing can have a maximum of 12 picture
						URLs hosted by eBay Picture Services or a maximum of 6 picture URLs
						hosted by a third-party vendor. If you specify multiple vendor-hosted
						pictures in listing calls, PhotoDisplay must be set to
						VendorHostedPictureShow. You cannot mix vendor-hosted and
						site-hosted pictures within the same listing.&lt;br&gt;&lt;br&gt;
						On the US eBay Motors site (for all vehicle listings), and on the
						eBay Canada site for motors, the picture pack of a listing can
						contain up to 24 photos. &lt;br&gt;&lt;br&gt;
						On the eBay Live Auctions site, a listing can have a maximum of 5
						picture URLs hosted by eBay Picture Services or a third
						party.&lt;br&gt;&lt;br&gt;
						If you embed pictures in the description (by using IMG tags) instead
						of using PictureURL, but you want a camera icon to appear in search
						and listing pages, specify the following "clear image" URL in
						PictureURL: http://pics.ebay.com/aw/pics/dot_clear.gif. This clear
						image is not supported for eBay Express.&lt;br&gt;&lt;br&gt;
						For VerifyAddItem, you can use the following fake eBay Picture
						Services URL (http://i2.ebayimg.com/abc/M28/dummy.jpg) to verify
						that your application is obtaining the correct fees for the quantity
						of images you pass in.&lt;br&gt;&lt;br&gt;
						To remove a picture when revising or relisting an item, specify
						PictureDetails with all the pictures that you want the listing to
						include. That is, you need to completely replace the original set of
						URLs with the revised set. To remove all pictures from a listing,
						specify item.PictureDetails.PictureURL in DeletedField.
					</xs:documentation>
					<xs:appinfo>
							<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PictureSource" type="ns:PictureSourceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The service hosting the images in PictureURL, if any.
					This information is primarily useful for Picture Manager subscribers, who pay a
					flat subscription fee instead of individual picture fees per listing.
					Only returned when PictureURL is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerActionCodeList.xsd #####

-->
	<xs:simpleType name="PictureManagerActionCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies an action to be performed on a folder or setting in the user's Picture
				Manager account.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Add">
				<xs:annotation>
					<xs:documentation>
						(in) Adds a folder, picture, or setting  to the account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delete">
				<xs:annotation>
					<xs:documentation>
						(in) Deletes a folder, picture, or setting from the account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Rename">
				<xs:annotation>
					<xs:documentation>
						(in) Renames a folder or picture.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Move">
				<xs:annotation>
					<xs:documentation>
						(in) Moves a picture to another folder.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Change">
				<xs:annotation>
					<xs:documentation>
						(in) Changes a subscription level.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerDetailLevelCodeList.xsd #####

-->
	<xs:simpleType name="PictureManagerDetailLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies a detail level for a response to a Picture Manager call.
				Use a value for this element, rather than a value for DetailLevel.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ReturnAll">
				<xs:annotation>
					<xs:documentation>
						(in) All pictures, folders, and account settings. Default value.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReturnSubscription">
				<xs:annotation>
					<xs:documentation>
						(in) Only data about the account subscription.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReturnPicture">
				<xs:annotation>
					<xs:documentation>
						(in) Return only data about pictures and folders in the authenticated user's account.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerDetailsType.xsd #####

-->
	<xs:complexType name="PictureManagerDetailsType">
		<xs:sequence>
			<xs:element name="SubscriptionLevel" type="ns:PictureManagerSubscriptionLevelCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The level of Picture Manager subscription. Each level has a monthly fee
						and provides a certain amount of storage space.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnSubscription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StorageUsed" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The amount of storage already in use. Measured in bytes. Read-only value.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnSubscription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalStorageAvailable" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The amount of storage space remaining in the authenticated user's album.
						Measured in bytes. Read-only value.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnSubscription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="KeepOriginal" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether to keep a copy of the original picture without resizing.
						Default is false. true = keep originals.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WatermarkEPS" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether to show the EPS watermark when photos are displayed.
						Default is false. true = show.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="WatermarkUserID" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether to show the user ID watermark when photos are displayed.
						Default is false. true = show.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Folder" type="ns:PictureManagerFolderType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The folder requested in the album.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerFolderType.xsd #####

-->
	<xs:complexType name="PictureManagerFolderType">
		<xs:annotation>
			<xs:documentation>
				 A folder in the authenticated user's album. By default, all folders and their pictures are
				 returned. If a folder ID is specified, the folders' metadata and contents are returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FolderID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The ID of the folder.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of the folder.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>55</MaxLength>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Picture" type="ns:PictureManagerPictureType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A picture within the folder, identified by a name, date, URL, and other metadata.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerPictureDisplayType.xsd #####

-->
	<xs:complexType name="PictureManagerPictureDisplayType">
		<xs:annotation>
			<xs:documentation>
				Defines various styles of picture display for images in Picture Manager albums.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DisplayType" type="ns:PictureManagerPictureDisplayTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						 The style of picture display, with a maximum size.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The URL to the image in the Picture Manager album.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Size" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The total file size of the picture, in bytes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Height" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The height of a specific image, or the maximum allowed height, in pixels.
						Varies for different calls.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Width" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The width of a specific image, or the maximum allowed width, in pixels.
						Varies for different calls.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerPictureDisplayTypeCodeList.xsd #####

-->
	<xs:simpleType name="PictureManagerPictureDisplayTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies the types of images that can be stored in a Picture Manager album.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Thumbnail">
				<xs:annotation>
					<xs:documentation>
						(in/out) A small image, thumbnail size. Maximum size 96 pixels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BIBO">
				<xs:annotation>
					<xs:documentation>
						(in/out) A BIBO image. Maximum size 200 pixels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Standard">
				<xs:annotation>
					<xs:documentation>
						(in/out) A standard size image. Maximum size 400 pixels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Large">
				<xs:annotation>
					<xs:documentation>
						(in/out) A large image. Maximum size 500 pixels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Supersize">
				<xs:annotation>
					<xs:documentation>
						(in/out) A very large image. Maximum size 800 pixels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Original">
				<xs:annotation>
					<xs:documentation>
						(in/out) The original uploaded image.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerPictureType.xsd #####

-->
	<xs:complexType name="PictureManagerPictureType">
		<xs:annotation>
			<xs:documentation>
				A picture in a Picture Manager album.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PictureURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The URL that identifies the picture in the album. If a URI has
						spaces, replace them with %20.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of the picture, specified by the user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Date" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The date the picture was uploaded to the Picture Manager account.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplayFormat" type="ns:PictureManagerPictureDisplayType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						The type of picture display in Picture Manager.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerDetails</CallName>
							<DetailLevels>none, ReturnPicture, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetPictureManagerDetails</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerSubscriptionLevelCodeList.xsd #####

-->
	<xs:simpleType name="PictureManagerSubscriptionLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies the level of the authenticated user's Picture Manager subscription.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Free">
				<xs:annotation>
					<xs:documentation>
						(in/out) Free to Stores users.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Level1">
				<xs:annotation>
					<xs:documentation>
						(in/out) 10 MB of storage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Level2">
				<xs:annotation>
					<xs:documentation>
						(in/out) 50 MB of storage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Level3">
				<xs:annotation>
					<xs:documentation>
						(in/out) 125 MB of storage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Level4">
				<xs:annotation>
					<xs:documentation>
						(in/out) 300 MB of storage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PictureManagerSubscriptionType.xsd #####

-->
	<xs:complexType name="PictureManagerSubscriptionType">
		<xs:annotation>
			<xs:documentation>
				Describes one type of Picture Manager subscription that is available.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SubscriptionLevel" type="ns:PictureManagerSubscriptionLevelCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			      The level of the subscription.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Fee" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			      The monthly fee for the subscription. Read-only value.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StorageSize" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			      The total amount of storage space available for the subscription type.
			      Read-only value.
			    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetPictureManagerOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PictureSourceCodeList.xsd #####

-->
	<xs:simpleType name="PictureSourceCodeType">
		<xs:annotation>
			<xs:documentation>
Specifies the service that is used to host a listing's pictures.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="EPS">
				<xs:annotation>
					<xs:documentation>
                (out) The PictureURL images are hosted by eBay Picture Services
                and the seller is not a Picture Manager subscriber.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PictureManager">
				<xs:annotation>
					<xs:documentation>
                (out) The PictureURL images are hosted by eBay Picture Manager
                and the seller is a Picture Manager subscriber.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Vendor">
				<xs:annotation>
					<xs:documentation>
                (out) The PictureURL images are not hosted by eBay.
                (Only applicable to PictureDetails. Not applicable to SiteHostedPicture.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PriceRangeFilterType.xsd #####

-->
	<xs:complexType name="PriceRangeFilterType">
		<xs:annotation>
			<xs:documentation> 
        One of the data filters used when searching for items using
        GetSearchResults. Allows filtering based on the current price of items.
        Properties allow for defining a range within prices must fall to be
        returned in the result set, a minimum price for items returned, or a
        maximum price for items returned.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MaxPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Specifies the maximum current price an item listing can have to be included in
            the searches result set. Use alone to specify a maximum price or with MinPrice
            to define a range the items' prices must be.
            See "Data Types" in the eBay Web Services Guide for information about specifying
            double values.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Specifies the minimum current price an item listing can have to be included in
            the searches result set. Use alone to specify a minimum price or with MaxPrice
            to define a range the items' prices must be.
            See "Data Types" in the eBay Web Services Guide for information about specifying
            double values.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetSearchResults</CallName>
								<RequiredInput>No</RequiredInput>
							</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PricingRecommendationsType.xsd #####

-->
	<xs:complexType name="PricingRecommendationsType">
		<xs:annotation>
			<xs:documentation> 
				Pricing data returned from the Product Pricing engine.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ProductInfo" type="ns:ProductInfoType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A product's pricing data (if any) and brief information about the product. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProPackEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="ProPackEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the ProPack feature (a feature pack). If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProPackPlusEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="ProPackPlusEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the ProPackPlus feature (a feature pack). If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProStoresCheckoutPreferenceType.xsd #####

-->
	<xs:complexType name="ProStoresCheckoutPreferenceType">
	<xs:annotation>
		<xs:documentation>
			Details about ProStores and checkout preferences.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="CheckoutRedirectProStores" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Indicates whether third party checkout was enabled for ProStores.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserPreferences</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ProStoresDetails" type="ns:ProStoresDetailsType" minOccurs="0" maxOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Details about the store.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserPreferences</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProStoresDetailsType.xsd #####

-->
	<xs:complexType name="ProStoresDetailsType">
	<xs:annotation>
		<xs:documentation>
			Details about the store.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="SellerThirdPartyUsername" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The username associated with the store.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserPreferences</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="StoreName" type="xs:string" minOccurs="0" >
			<xs:annotation>
				<xs:documentation>
					The name of the store.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserPreferences</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="Status" type="ns:EnableCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The status--whether enabled or disabled.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserPreferences</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductArrayType.xsd #####

-->
	<xs:complexType name="ProductArrayType">
		<xs:annotation>
			<xs:documentation>
Container for a list of eBay Express products. Can contain zero, one, or multiple
ExpressProductType objects, each of which conveys the data for one product.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Product" type="ns:ExpressProductType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					Contains the data properties that define one eBay catalog product that matches the request, if any.
					GetSearchResultsExpress only returns products when matching products are found.
					For each product, the set of fields returned is controlled by the value of ProductDetails in the request.
					Multiple Product nodes can be returned (up to the amount specified in EntriesPerPage).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductFamilyType.xsd #####

-->
	<xs:complexType name="ProductFamilyType">
		<xs:annotation>
			<xs:documentation>
A set of results returned from a catalog product search. Use GetProductSearchResults 
or GetProductFamilyMembers to perform the search.
      See the guide for information about Pre-filled Item Information (Catalogs) functionality.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ParentProduct" type="ns:ProductType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A transient header that describes the current search results. Contains a 
            an ID, a subset of attributes, and a typical stock photo 
            to help a user easily distinguish the products in the current result set
            from products in other result sets returned in the same response. 
            One ParentProduct is returned per ProductFamily.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FamilyMembers" type="ns:ProductType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            A set of products (within the same product family) that match the search query. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="hasMoreChildren" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
         If true, the product family has more products than you requested in
         MaxChildrenPerFamily for a query in the GetProductSearchResults request. 
         In this case, no products are returned in the GetProductSearchResults response.
         (Call GetProductFamilyMembers to retrieve all products in the family.)
					If false, the product family has MaxChildrenPerFamily or fewer product
					children, and the call returns all products in the family.
         	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductFinderConstraintType.xsd #####

-->
	<xs:complexType name="ProductFinderConstraintType">
		<xs:annotation>
			<xs:documentation>
      An attribute (constraint) that was specified in a search request that was 
      based on a product finder query. Used to help you map each query in a batch
      request to the corresponding search result in the response.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DisplayName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The search attribute name (e.g., Manufacturer). 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplayValue" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The search attribute value the user specified in the query 
            (e.g., the actual name the user chose for the manufacturer).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductInfoType.xsd #####

-->
	<xs:complexType name="ProductInfoType">
		<xs:sequence>
			<xs:element name="AverageStartPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The average start price (minimum bid), if any, of completed auction items that were listed
            with Pre-filled Item Information from this product.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
							<Context>PricingRecommendations</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AverageSoldPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The average sold price (winning bid, Buy It Now price, or fixed price), if any, of
					completed items that were listed with Pre-filled Item Information from this product.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
							<Context>PricingRecommendations</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Title associated with the product. This value can be used as the basis for a
					suggested listing title. If the title is longer than 55 characters, your application
					should make sure the suggested title has a max length of 55 characters so that
					it will be valid for the AddItem family of calls.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>1024</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
		<xs:attribute name="productInfoID" type="xs:string">
			<xs:annotation>
				<xs:documentation>
				Unique identifier for the product. See the Developer's Guide for information about
				eBay product IDs. If the primary and secondary category are both catalog-enabled, this
				ID corresponds to the primary category.
				</xs:documentation>
					<xs:appinfo>
						<MaxLength>4000</MaxLength>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductListingDetailsType.xsd #####

-->
	<xs:complexType name="ProductListingDetailsType">
		<xs:annotation>
			<xs:documentation>
				Contains product information that can be included in a listing.
				Applicable for listings that use eBay's Pre-filled Item Information feature.
				See the Developer's Guide for details on working with Pre-filled Item Information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ProductID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applicable when ProductListingDetails is used. Unique identifier for
						the product. See the Developer's Guide for information about determining product IDs.
						If the primary and secondary categories are both catalog-enabled, this ID should correspond to the primary
						category (not the secondary category).
						In item-listing requests, if you pass in an old product ID, eBay will
						list the item with the latest version of the product and the latest product ID, and the call
						will return a warning indicating that the data has changed.
						To list an item with Pre-filled Item Information by
						using an ISBN, EAN, or UPC value, use ExternalProductID (defined on AddItem) instead.
						Either ExternalProductID (for an ISBN, UPC, EAN or eBay product ID)
						or Item.ProductListingDetails.ProductID (for an eBay product ID) can be specified
						in AddItem requests, but not both.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>4000</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IncludeStockPhotoURL" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the item listing includes the stock photo.
						To use an eBay stock photo in an item listing, set IncludeStockPhotoURL to true.
						If a stock photo is available, it is used at the top of the View Item page and in
						the Item Specifics section of the listing. If you also include Item.PictureDetails.PictureURL,
						the stock photo only appears in the Item Specifics section of the listing. Other pictures
						you specify by using Item.PictureDetails.PictureURL appear in a separate section of the listing.
						If you use Item.ExternalProductID instead of Item.ProductListingDetails,
						eBay sets IncludeStockPhotoURL to true (and you cannot set it to false).
						In GetItem, the URL of the stock photo will be returned in StockPhotoURL.
						If you set IncludeStockPhotoURL to false, the stock photo does not appear in the listing at all.&lt;br&gt;&lt;br&gt;
						To be considered for eBay Express, in most cases a listing must include a picture or a gallery URL.
						You can choose to use the eBay stock photo for this purpose.
						See "Working with eBay Express Listings" in the eBay Web Services Guide.&lt;br&gt;&lt;br&gt;
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IncludePrefilledItemInformation" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, specifies that the listing should include additional information about the product,
						such as a publisher's description or film credits. Such information is hosted through the eBay site
						and cannot be edited. If true, Item.Description is optional in item-listing requests.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UseStockPhotoURLAsGallery" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the stock photo for an item (if available) is
						used as the gallery thumbnail. When listing an item, IncludeStockPhotoURL
						must also be true and Item.PictureDetails.GalleryType must be passed in with a value of Gallery
						or Gallery Featured (but not both). Passing in Item.PictureDetails.GalleryURL takes precedence
						over UseStockPhotoURLAsGallery. See "Describing Items in a Listing" in the
						eBay Web Services Guide for additional validation rules for pictures.
						If you use Item.ExternalProductID instead of Item.ProductListingDetails,
						eBay sets UseStockPhotoAsGallery to true (and you cannot set it to false).
						To be considered for eBay Express, in most cases a listing must include a picture or a gallery URL.
						You can choose to use the eBay stock photo for this purpose.
						See "Working with eBay Express Listings" in the eBay Web Services Guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StockPhotoURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Fully qualified URL for a standard image (if any) that is associated with the product.
						A seller can choose to include the stock photo in the listing and as the gallery thumbnail
						by setting IncludeStockPhotoURL and UseStockPhotoURLAsGallery to true. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>							
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Copyright" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Copyright statement indicating the source of the product information. This information will be
						included in the listing with Pre-filled Item Information. Your application should also display
						the copyright statement when rendering the Pre-filled Item Information.
						If more than one copyright statement is applicable, they can be presented to the
						user in alphabetical order. Returned as HTML.
						Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductRecommendationsType.xsd #####

-->
	<xs:complexType name="ProductRecommendationsType">
		<xs:annotation>
			<xs:documentation> 
				A list of products returned from the Suggested Attributes engine.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Product" type="ns:ProductInfoType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
            A suggested product to use to list an item with Pre-filled Item Information.
            Returned from GetItemRecommendations when the Suggested Attributes engine is used 
            See the Developer's Guide for additional details.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemRecommendations</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductSearchPageType.xsd #####

-->
	<xs:complexType name="ProductSearchPageType">
		<xs:annotation>
			<xs:documentation>

			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DataElements" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Replaced by DataElementSet.DataElement as of release 449. 
						This field is still returned for backward compatibility, but it may be deprecated 
						in a future release. Applications should remove dependencies on this element and 
						start using DataElementSet.DataElement instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchCharacteristicsSet" type="ns:CharacteristicsSetType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
          A list of attributes that describe the choice of search criteria 
          for the specified characteristic set. The order in which the criteria are returned 
          is not significant and may vary for different requests. See the eBay Web Services guide 
          for details about how to use this data as input to GetProductSearchResults.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchType" type="ns:CharacteristicsSearchCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
          Indicates whether one attribute or multiple attributes can be used as the search keyword 
          when calling GetProductSearchResults. Applications can ignore this data because 
          GetProductSearchPage only supports single-attribute searches.
          Use GetProductFinder to determine valid multi-attribute searches.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SortCharacteristics" type="ns:CharacteristicType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
          A product aspect or feature that can be used as a key for sorting catalog search results. 
          This does not necessarily match a searchable attribute. For example, you might be able to 
          search on a product's title but sort the results by the release date or the manufacturer's 
          suggested retail price (MSRP). At least one sort attribute is always returned.
          Applications should ensure that only one attribute is selected as a sort key from 
          these results (before calling GetProductSearchResults). The default sort key is the one 
          with the lowest DisplaySequence value.
          The order in which the SortCharacteristics nodes are returned is not significant and may vary for 
          different requests.
          See the eBay Web Services guide for details about how to use this data as input to 
          GetProductSearchResults.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DataElementSet" type="ns:DataElementSetType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					Contains helpful hints for the user. Usage of this information is optional. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchPage</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductSearchResultType.xsd #####

-->
	<xs:complexType name="ProductSearchResultType">
		<xs:annotation>
			<xs:documentation>
Container for the results of a product query. 
Supports Pre-filled Product Information functionality.
See the Developer's Guide for more information about working with this data.
				</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ApproximatePages" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
               (out) The approximate quantity of pages of results that match the product search query 
               (TotalProducts divided by the median number of products per page examined so far). 
               Lowest value is 1.
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               For GetProductFamilyMembers, obsolete (not returned) with compatibility level 415 and higher.
               Applications should remove dependencies on this field and use AttributeSet.ApproximatePages instead.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSetID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
               (out) Constant value that identifies the attribute set in a language-independent way.
               Unique across all eBay sites. Corresponds to a characteristic set associated 
               with the current set of search results.
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               For GetProductFamilyMembers, obsolete (not returned) with compatibility level 415 and higher.
               Applications should remove dependencies on this field and use AttributeSet.AttributeSetID instead.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="HasMore" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	            (out) If true, the query results contain additional pages (higher than the current page number). 
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               For GetProductFamilyMembers, obsolete (not returned) with compatibility level 415 and higher.
               Applications should remove dependencies on this field and use AttributeSet.HasMore instead.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFamilies" type="ns:ProductFamilyType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
               (out) ProductFamilies represents one product family. Multiple ProductFamilies 
               properties can be returned. A product family identifies a group of related products. 
               For example, the movie "My Favorite Movie: The Sequel" might be released on DVD, but there 
               might be several editions of the DVD (e.g., in different languages) with different ISBN numbers. 
               All variations are part of the same product family ("My Favorite Movie: The Sequel" in the DVD format). 
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               For GetProductFamilyMembers, obsolete (not returned) with compatibility level 415 and higher.
               Applications should remove dependencies on this field and use AttributeSet.ProductFamilies instead.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderConstraints" type="ns:ProductFinderConstraintType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
	            A list of attributes (constraints) that were specified in the search request.
               This information is useful when multiple queries were specified in a 
               GetProductSearchResults request. Use this information to map each query
               to each result in the response object.
               Applicable when the search request was constructed based on a product finder.
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               Applications should remove dependencies on this field and use AttributeSet.ProductFinderConstraints instead.
               Not applicable to GetProductFamilyMembers.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="TooManyMatchesFound" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
               (out) If too many search results match the query, the TooManyMatchesFound tag is returned with a warning. 
               In this case, it may be a good idea to ask the user to specify more details to narrow the search 
               (e.g., specify "My Favorite Movie" instead of "My").
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               Applications should remove dependencies on this field and use AttributeSet.TooManyMatchesFound instead.
	            Not applicable to GetProductFamilyMembers.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalProducts" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	            (out) The total quantity of products that match the query
	            (within the characteristic set). 
               This can exceed the actual number of products returned in 
               the current virtual page.
               For GetProductSearchResults, obsolete (not returned) with compatibility level 387 and higher.
               For GetProductFamilyMembers, obsolete (not returned) with compatibility level 415 and higher.
               Applications should remove dependencies on this field and use AttributeSet.TotalProducts instead.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
               (out) Key you specified in ProductSearchID in the search request to 
               distinguish between query results. Primarily useful when conducting 
               multiple searches in the same call. If no ProductSearchID value was 
               specified in the request, returns the array index of the search result 
               (beginning with 0). Not applicable to GetProductFamilyMembers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NumProducts" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
               (out) Total quantity of products that match the search request 
               (across all characteristic sets). This value can exceed the actual 
               quantity of products returned in the current virtual page.
               Not applicable to GetProductFamilyMembers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSet" type="ns:ResponseAttributeSetType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
               (out) A result containing a set of one or more product families. 
               For GetProductSearchResults, if QueryKeywords and multiple characteristic set IDs were 
               specified in the request, multiple AttributeSet objects can be returned. 
               Each AttributeSet corresponds to a characteristic set ID specified 
               in the request. See the eBay Web Services guide for more information 
               about working with this data.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               For GetProductFamilyMembers, only returned with compatibility level 415 and higher.
               For lower compatibility levels, see ProductSearchResult.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplayStockPhotos" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
               (out) If true, your application should attempt to display stock photos that are returned. 
               If false, your application should not attempt to display any stock photos that are returned. 
               This recommendation is useful for catalog data related to products like coins, 
               where stock photos are not applicable. 
               An application with a graphical user interface can use this flag 
               to determine when to hide stock photo widgets for a set of search results.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductSearchType.xsd #####

-->
	<xs:complexType name="ProductSearchType">
		<xs:annotation>
			<xs:documentation>
      Container for a product query and pagination instructions.
      This data is applicable when searching eBay catalogs for stock product
      information (to use in listings with Pre-filled Item Information.)
      Input only.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ProductSearchID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Unique alphanumeric key help you distinguish between query results in the response.
            You define the key. Each search request ID must be unique within the same call.
            Primarily useful when conducting multiple searches in the same call.
            If not specified, the ProductSearchResult.ID values in the response are
            indexed starting from 0 (zero).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSetID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						Identifier for a characteristic set (an attribute set) that is mapped to
						a catalog-enabled category (unique across all eBay sites).
						Required when you use SearchAttributes
						(for searches based on product search page and product finder data).
						Returns an error with QueryKeywords (use CharacteristicSetIDs instead).
						Use GetProductSearchPage or GetProductFinder to determine valid IDs for the
						type of search you are performing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Required when you are performing a sell-side product finder search.
						(Not applicable to product search page searches.)
            Numeric identifier for a sell-side product finder that was used to retrieve
            the search attributes being used in the request. The product finder must be
            mapped to a catalog-enabled category (i.e., it cannot be a buy-side product finder ID)
            associated with the characteristics set.
            Use a product finder when you want to specify multiple attributes in a
            product search query. Call GetCategory2CS to determine which categories
            support sell-side product finder searches.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Identifier for a representative stock product in a product family.
            Used as input in GetProductFamilyMembers requests to identify a product family.
            Use GetProductSearchResults to determine the available IDs.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>4000</MaxLength>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SortAttributeID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for a sortable attribute. Use GetProductSearchPage
						or GetProductFinder to determine the valid sort attribute IDs for the
						specified characteristic set (including the default sort attribute that will be
						used if you do not specify this field).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxChildrenPerFamily" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Pagination instruction that specifies the maximum quantity of products to return for each
            product family within the search response whose ID matches the current request's ID.
            In the response, if the last family returned contains MaxChildrenPerFamily or fewer
            additional products, those additional products are also returned (i.e., the actual quantity
            returned for the last family can exceed the specified maximum value).
            See "Limit the Quantity of Products Returned Per Family" in the eBay Web Services Guide.
            The value should not include punctuation (i.e., a thousands separator is not valid).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<Min>1</Min>
							<Max>20000</Max>
							<Default>5</Default>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchAttributes" type="ns:SearchAttributesType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A predefined attribute against which to search (e.g., Author).
						Use this to create a query based on a set of Item Specifics from the catalog.
						Both the product title and product Item Specifics are searched.
						If the query includes multiple SearchAttributes fields (one for each attribute),
						the search engine will apply "AND" logic to the query.
						Call GetProductSearchPage or GetProductFinder to determine the list of valid attributes and how many are
						permitted for the specified characteristic set. See the eBay Web Services guide for details.
						For each ProductSearch, either SearchAttributes or QueryKeywords is required (but do not pass both).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Pagination" type="ns:PaginationType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Pagination instruction that specifies the virtual page of data to return
            per search request. Default page number is 0 (the first page).
            Specify a page number of 0 or a positive value lower
            than the approximate number of pages available.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AvailableItemsOnly" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Filter to only retrieve products that match active eBay listings.
						This may be used as an indicator to determine which products other sellers
						recently used to pre-fill similar listings.
						If true, only retrieve products that have been used to pre-fill active listings on the
            specified eBay site.
						If false, retrieve all products that match the query.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
							<Default>false</Default>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QueryKeywords" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						One or more keywords to search for in the characteristic set specified in
            CharacteristicSetIDs. Both the product title and Item Specifics are searched.
						For each ProductSearch, either SearchAttributes or QueryKeywords is required
						(but do not pass both). Blank searches are not applicable (and result in a warning).
						The words "and" and "or" are treated like any other word.
						Only use "and", "or", or "the" if you are searching for products containing
						these words. To use AND or OR logic, use eBay's standard search string modifiers.
						Wildcards (+, -, or *) are also supported. Be careful when using spaces before or after
						modifiers and wildcards.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>350</MaxLength>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharacteristicSetIDs" type="ns:CharacteristicSetIDsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
             List of one or more characteristic set IDs that indicate which characteristic sets
             to search in. If not specified, the search is conducted across all characteristic sets.
						Only applicable when QueryKeywords is specified. Ignored when SearchAttributes is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductType.xsd #####

-->
	<xs:complexType name="ProductType">
		<xs:annotation>
			<xs:documentation>
      A prototype description of a well-known type of item, such as a popular book.
      Applicable when working with eBay's Pre-filled Item Information feature.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CharacteristicsSet" type="ns:CharacteristicsSetType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A set of characteristics that describe the product in a standardized way.
            In responses, only the attributes and values that applicable for the
            specified product are returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductSellingPages</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DetailsURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Fully qualified URL for optional information about the product,
            such as a movie's description or film credits. This information
            is hosted through the eBay site and cannot be edited.
            Applications can include this URL as a link in product search results
            so that end users can view additional descriptive details about the product.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<Context>FamilyMembers</Context>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NumItems" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Total number of active listings on the specified eBay site
            that were pre-filled based on this product.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Context>FamilyMembers</Context>
							<Returned>Always</Returned>
							<Min>0</Min>
							<Max/>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Lowest current price of active and ended listings on the specified eBay site that were
            pre-filled based on this product. The value is in the specified site's currency.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Context>FamilyMembers</Context>
							<Returned>Always</Returned>
							<Min>0.0</Min>
							<Max/>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Highest current price of active and ended listings on the specified eBay site that were
						pre-filled based on this product. The value is in the specified site's currency.
						Round numbers (such as 15.0) may only show one zero after the decimal (as with any double in the schema).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Context>FamilyMembers</Context>
							<Returned>Always</Returned>
							<Min>0.0</Min>
							<Max/>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
		<xs:attribute name="productID" type="xs:string">
			<xs:annotation>
				<xs:documentation>
         Unique identifier for the product. The ID is defined in an eBay catalog.
         Product IDs may change over time. Therefore, use the catalog search calls
         (GetProductSearchResults and GetProductFamilyMembers)
         to update any product IDs that you store locally.
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>4000</MaxLength>
					<CallInfo>
						<CallName>GetProductFamilyMembers</CallName>
						<CallName>GetProductSearchResults</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetProductSellingPages</CallName>
						<RequiredInput>Yes</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="stockPhotoURL" type="xs:anyURI">
			<xs:annotation>
				<xs:documentation>
					Fully qualified URL for a standard image that is associated with the product, if available.
         Allows the user to preview the image from your application.
         A user can choose to include the stock photo in a listing.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetProductFamilyMembers</CallName>
						<CallName>GetProductSearchResults</CallName>
						<CallName>GetProductSearchPage</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="title" type="xs:string">
			<xs:annotation>
				<xs:documentation>
         The name of the product, as defined within the catalog. Not necessarily the
         same as the "Title" attribute in the characteristics set meta-data, if any.
         On the eBay site, this title serves as the basis for the suggested item title
         (truncated to the max length permitted for Title in item-listing calls).
         Applications can use this value to supply a suggested listing title to users.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetProductFamilyMembers</CallName>
						<Context>FamilyMembers</Context>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetProductSearchResults</CallName>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProductUseCaseCodeList.xsd #####

-->
	<xs:simpleType name="ProductUseCaseCodeType">
		<xs:annotation>
			<xs:documentation>
Specifies the context in which the product selling page is being called, 
which will imply certain validation rules. Use this code list to make sure 
you retrieve the appropriate version of product information and characteristic 
meta-data when you are listing an item with Pre-filled Item Information.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AddItem">
				<xs:annotation>
					<xs:documentation>
            (in) Use this code when calling GetProductSellingPages 
            before adding an item. This retrieves the latest product ID and the corresponding characteristic meta-data. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSellingPages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ReviseItem">
				<xs:annotation>
					<xs:documentation>
            (in) Use this code when calling GetProductSellingPages 
            before revising an item that already contains product information. 
            If the product ID or data has changed, the original 
            product ID that you passed in and the data associated with that original version of the 
            product is returned. This is useful because the original Pre-filled Item Information 
            is used when you call ReviseItem.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSellingPages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RelistItem">
				<xs:annotation>
					<xs:documentation>
            (in) Use this code when calling GetProductSellingPages 
            before relisting an item that already contains product information. 
            This retrieves the latest product ID and the 
            corresponding characteristic meta-data (same data as AddItem). 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSellingPages</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PromotedItemType.xsd #####

-->
	<xs:complexType name="PromotedItemType">
		<xs:annotation>
			<xs:documentation>
				Contains the data describing one cross-promoted item.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  The unique ID of the cross-promoted item.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PictureURL" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						URL for an image hosted by eBay Picture Services (EPS) or self-hosted for
						the promoted item, if any.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SelfHostedURL" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For an item listed with multiple self-hosted pictures, contains the URLs of the
						self-hosted pictures in addition to the one listed in PictureURL.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Position" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The ordinal position of the cross-promoted item
						in the display. If the display is from top to bottom,
						1 is at top. If the display is from left to right, 1
						is at left. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotionPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The price of the cross-promoted item. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotionPriceType" type="ns:PromotionItemPriceTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The listing type for the promoted item and how the item price
						is used, either AuctionPrice or BuyItNowPrice.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SelectionType" type="ns:PromotionItemSelectionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The manner in which the cross-promoted item was chosen
						to be associated with the referring item. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The title of the promoted item for display in the
						referring item's page. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingType" type="ns:ListingTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The listing type under which the cross-promoted item
						is being offered. Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCrossPromotions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PromotionItemPriceTypeCodeList.xsd #####

-->
	<xs:simpleType name="PromotionItemPriceTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				PromotionItemPriceTypeCodeType - Type declaration to be used by other schema. 
				Indicates the type of offer that can be made for a cross-promoted item. Note that 
				for a Chinese listing with a still-active Buy It Now option, either a Bid 
				(Auction) or a Buy It Now type offer may be made.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AuctionPrice">
				<xs:annotation>
					<xs:documentation>
						(out) Bid offer in a competitive-bidding listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyItNowPrice">
				<xs:annotation>
					<xs:documentation>
						(out) Buy It Now offer in a fixed-price or Buy It Now listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BestOfferOnlyPrice">
				<xs:annotation>
					<xs:documentation>
						(out) Best Offer in Best Offer Only listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ClassifiedAdPrice">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PromotionItemSelectionCodeList.xsd #####

-->
	<xs:simpleType name="PromotionItemSelectionCodeType">
		<xs:annotation>
			<xs:documentation>
           PromotionItemSelectionCodeType - Type declaration to be used by
           other schema. Indicates how the cross-promoted item was selected for
           association with the referring item. If the seller defined an
           item-to-item cross-promotion rule and the item was selected because
           of that rule, then "Manual" is returned. If the seller defined some
           other rule and the item was selected because of that rule (or the
           seller defined no rules that could be applied), then "Automatic" is
           returned.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Manual">
				<xs:annotation>
					<xs:documentation>
                (out) Manual selection.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Automatic">
				<xs:annotation>
					<xs:documentation>
                (out) Automatic selection.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PromotionMethodCodeList.xsd #####

-->
	<xs:simpleType name="PromotionMethodCodeType">
		<xs:annotation>
			<xs:documentation>
			  Indicates the type of cross-promotion used.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="CrossSell">
				<xs:annotation>
					<xs:documentation>
                (in/out) A cross-sell. The seller presents items that are
				related to or can be used with the item the buyer is bidding on or has
				purchased.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UpSell">
				<xs:annotation>
					<xs:documentation>
                (in/out) An upsell. The seller presents items that are higher 
				quality or more expensive than the item the buyer is bidding 
				on or has purchased.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (in/out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/PromotionRuleArrayType.xsd #####

-->
	<xs:complexType name="PromotionRuleArrayType">
		<xs:annotation>
			<xs:documentation> 
			Contains a list of cross-promotion rules. Each PromotionRuleType
			defines one rule.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PromotionRule" type="ns:PromotionRuleType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
					  Defines one cross-promotion rule.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PromotionRuleType.xsd #####

-->
	<xs:complexType name="PromotionRuleType">
		<xs:annotation>
			<xs:documentation>
			  Defines a rule that promotes items or a store category when
			  a buyer views a specific item or store category.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PromotedItem" type="ns:PromotedItemType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					The unique item ID of the cross-promoted item. Use for an
					ItemToItem rule.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteID" type="ns:SiteCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						 The site associated with the referring eBay category. Required only if
						 the rule uses a referring eBay category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotedStoreCategoryID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The ID of the Store category being promoted. Use with a promotion scheme of
					ItemToStoreCat, StoreToStoreCat, ItemToDefaultRule, or
					DefaultRule. Only for Store owners.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotedeBayCategoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The ID of the eBay category being promoted. Use with a promotion scheme of
					ItemToDefaultRule or DefaultRule.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotedKeywords" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The keywords that identify promoted items. Use with a promotion scheme of
					ItemToDefaultRule or DefaultRule. Only for Store owners.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReferringItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The unique ID of the item the buyer is viewing or purchasing.
					Use with a promotion scheme of ItemToItem or ItemToStoreCat.
					Always use ReferringItemID or ReferringStoreCategoryID, but
					not both.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReferringStoreCategoryID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The ID of the store category the user is browsing. Use with a
					promotion scheme of 
					StoreToStoreCat, ItemToDefaultRule or DefaultRule.
					Always use ReferringStoreCategoryID or ReferringItemID, but
					not both.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReferringeBayCategoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The ID of the eBay category being referred. Use with a promotion scheme
					or ItemToDefaultRule or DefaultRule.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReferringKeywords" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The keywords that identify referring items. Use with a promotion scheme of
					ItemToDefaultRule or DefaultRule. Only for Store owners.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotionScheme" type="ns:PromotionSchemeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					The type of cross-promotion scheme you are defining.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PromotionMethod" type="ns:PromotionMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					The type of cross promotion, CrossSell or UpSell.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetPromotionRules</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetPromotionRules</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PromotionSchemeCodeList.xsd #####

-->
	<xs:simpleType name="PromotionSchemeCodeType">
		<xs:annotation>
			<xs:documentation>
           Identifies the scheme used for a cross-promotion rule.
           The scheme defines referring and promoted items and categories.
           To define a rule scheme, you must be the owner of an eBay Store.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ItemToItem">
				<xs:annotation>
					<xs:documentation>
                (in/out) The seller specifies individual items in the store that are
				promoted when a buyer views, bids on, or
				purchases a store item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemToStoreCat">
				<xs:annotation>
					<xs:documentation>
                (in/out) The seller specifies a store category from 
				which items are promoted when a buyer views, bids on,
				or purchases an individual item in the store.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StoreToStoreCat">
				<xs:annotation>
					<xs:documentation>
                (in/out) The seller specifies referring and promoted categories, both from
                the store. When a buyer views or acts on any item from that category, items
                from the promoted category are also displayed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemToDefaultRule">
				<xs:annotation>
					<xs:documentation>
                (in/out) The seller specifies a referring item and defines promoted items
                selected from a store category, eBay category, or keywords.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DefaultRule">
				<xs:annotation>
					<xs:documentation>
                (in/out) The seller specifies a store category or eBay category, with optional
                keywords, for referring items and one for promoted items. When a referring item
                is selected from the category and keywords, items from the promoted category and
                keywords are also displayed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CategoryProximity">
				<xs:annotation>
					<xs:documentation>
		(out) This scheme is returned as a backfill scheme used to promote items.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ProximitySearchDetailsType.xsd #####

-->
	<xs:complexType name="ProximitySearchDetailsType">
		<xs:annotation>
			<xs:documentation>
				Contains information for use in proximity search.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PostalCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The postal code where the item is located. This response element is 
						deprecated and may be removed from the schema in a future release. 
						Remove application dependencies on this element. For item location, refer to 
						Item.PostalCode instead.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetSellerList</CallName>
								<Returned>Conditionally</Returned>
								<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
								<TagStatus>Deprecated</TagStatus>
							</CallInfo>
							<CallInfo>
								<CallName>GetBidderList</CallName>
								<Returned>Always</Returned>
								<TagStatus>Deprecated</TagStatus>
							</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ProximitySearchType.xsd #####

-->
	<xs:complexType name="ProximitySearchType">
		<xs:annotation>
			<xs:documentation>
					Contains data for filtering a search by proximity.
				</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MaxDistance" type="xs:int">
				<xs:annotation>
					<xs:documentation>
							The maximum distance from the specified postal code to search for items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PostalCode" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							The postal code to use as the basis for the proximity search.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>							
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/PurchasePurposeTypeCodeList.xsd #####

-->
	<xs:simpleType name="PurchasePurposeTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				The purpose of a purchase (e.g., by a PayPal application).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
						Custom Code
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyNowItem">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShoppingCart">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AuctionItem">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GiftCertificates">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Subscription">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Donation">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayBilling">
				<xs:annotation>
					<xs:documentation/>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/QuantityOperatorCodeList.xsd #####

-->
	<xs:simpleType name="QuantityOperatorCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="LessThan">
				<xs:annotation>
					<xs:documentation>
						Used by QuantityOperator to specify that you are seeking quantities less than Quantity.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LessThanOrEqual">
				<xs:annotation>
					<xs:documentation>
						Used by QuantityOperator to specify that you are seeking quantities less than or equal to Quantity.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Equal">
				<xs:annotation>
					<xs:documentation>
						Used by QuantityOperator to specify that you are seeking quantities equal to Quantity.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GreaterThan">
				<xs:annotation>
					<xs:documentation>
						Used by QuantityOperator to specify that you are seeking quantities greater than Quantity.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GreaterThanOrEqual">
				<xs:annotation>
					<xs:documentation>
						Used by QuantityOperator to specify that you are seeking quantities greater than or equal to Quantity.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/QuestionTypeCodeList.xsd #####

-->
	<xs:simpleType name="QuestionTypeCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="General">
			  <xs:annotation>
			  	<xs:documentation>
			  		General questions about the item.
			  	</xs:documentation>
			  </xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="Shipping">
				<xs:annotation>
					<xs:documentation>
						 Questions related to the shipping of the item.
					</xs:documentation>
			  </xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Payment">
				<xs:annotation>
					<xs:documentation>
						Questions related to the payment for the item.
					</xs:documentation>
			  </xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MultipleItemShipping">
				<xs:annotation>
					<xs:documentation>
						Questions related to the shipping of this item
						bundled with other items also purchased on eBay.
					</xs:documentation>
			  </xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Not available.
					</xs:documentation>
			  </xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RCSPaymentStatusCodeList.xsd #####

-->
	<xs:simpleType name="RCSPaymentStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				The status of a payment.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Canceled">
				<xs:annotation>
					<xs:documentation>
						Payment is in canceled state.
					</xs:documentation>
					<!-- N/A to GetSellerPayments -->
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Paid">
				<xs:annotation>
					<xs:documentation>
						Payment is in completed state.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						Payment is in pending state.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RangeCodeList.xsd #####

-->
	<xs:simpleType name="RangeCodeType">
		<xs:annotation>
			<xs:documentation>
           Type declaration to be used by other schema. Indicates that the data
           represents the high or low end in a range, such as a date range,
           price range, or width range. (For example, when calling
           GetProductSearchResults, you use range codes to indicate the role of
           an attribute in a range.)
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="High">
				<xs:annotation>
					<xs:documentation>
                High end of the range.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Low">
				<xs:annotation>
					<xs:documentation> 
                Low end of the range.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RecipientRelationTypeCodeList.xsd #####

-->
	<xs:simpleType name="RecipientRelationCodeType">
		<xs:annotation>
			<xs:documentation>
				A seller can make a Transaction Confirmation Request (TCR) for an item.
				This code list contains values to specify the current relationship between the seller and the potential buyer.
				For a seller to make a Transaction Confirmation Request (TCR) for an item, the potential buyer must
				meet one of the criteria in this code list.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="1">
				<xs:annotation>
					<xs:documentation>
						Indicates that the recipient has one or more bids on the item; the relationship is "bidder."
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="2">
				<xs:annotation>
					<xs:documentation>
						Indicates that the recipient has one or more best offers on the item; the relationship is "best offer buyer." 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="3">
				<xs:annotation>
					<xs:documentation>
						Indicates that the recipient has asked the seller a question about the item; the relationship is "a member with an ASQ question." 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="4">
				<xs:annotation>
					<xs:documentation>
						Indicates that the recipient has a postal code; the relationship is "a member with a postal code."
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
            Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RecommendationEngineCodeList.xsd #####

-->
	<xs:simpleType name="RecommendationEngineCodeType">
		<xs:annotation>
			<xs:documentation>
RecommendationEngineCodeType - Type declaration to be used by other schema.
Identifies the engines that can be used to analyze proposed listing data. 
See the Developer's Guide for a list of recommendation engines that 
are currently operational.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ListingAnalyzer">
				<xs:annotation>
					<xs:documentation>
                (in) Listing Analyzer engine; Returns tips related to fields 
                that a seller wants to specify in a listing.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SIFFTAS">
				<xs:annotation>
					<xs:documentation>
                (in) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ProductPricing">
				<xs:annotation>
					<xs:documentation>
                (in) Product Pricing engine. Returns average start and sold prices 
                of completed items that were listed a specified product ID.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>				
			</xs:enumeration>
			<xs:enumeration value="SuggestedAttributes">
				<xs:annotation>
					<xs:documentation>
                (in) Suggested Attributes engine. Returns suggested Item Specifics
                and catalog products (for Pre-filled Item Information) that have been 
                used by other sellers who listed similar items in the same category.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>			
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RefundReasonCodeList.xsd #####

-->
	<xs:simpleType name="RefundReasonCodeType">
		<xs:annotation>
			<xs:documentation>
Explanation of the reason that the refund is being issued. Applicable to Half.com refunds only.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="CannotShipProduct">
				<xs:annotation>
					<xs:documentation>
					Seller is unable to ship the product to the buyer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WrongItemShipped">
				<xs:annotation>
					<xs:documentation>
					Seller shipped the wrong item to the buyer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemBadQuality">
				<xs:annotation>
					<xs:documentation>
					The buyer returned the item due to its quality.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ItemDamaged">
				<xs:annotation>
					<xs:documentation>
					The buyer returned the item due to damage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerRemorse">
				<xs:annotation>
					<xs:documentation>
					The buyer decided they did not want the item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RefundTypeCodeList.xsd #####

-->
	<xs:simpleType name="RefundTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				Explanation of the reason that the refund is being issued. Applicable to Half.com
				refunds only.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Full">
				<xs:annotation>
					<xs:documentation>
					The seller has issued a refund for the transaction price that
					was originally paid to the seller.
					(The seller's shipping reimbursement is not included
					if Half.com calculates the refund amount).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FullPlusShipping">
				<xs:annotation>
					<xs:documentation>
						The seller has issued a refund for the transaction price and
						shipping reimbursement that was originally paid to the seller.
						(The buyer's return shipping costs
						might not be included if Half.com calculates the refund amount.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomOrPartial">
				<xs:annotation>
					<xs:documentation>
						The seller has issued a refund amount that is different from
						the full refund (with or without shipping). If specified,
						it may be helpful to explain the amount in your note to the buyer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/RegionDetailsType.xsd #####

-->
	<xs:complexType name="RegionDetailsType">
		<xs:annotation>
			<xs:documentation> 
				Details about a region.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="RegionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Numeric identifier for a region within a country.&lt;br&gt;&lt;br&gt;
						Related field:&lt;br&gt;
						Item.RegionID in GetItem&lt;br&gt;
						(Ignore region values for all sites except China.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Full name of the region.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ReminderCustomizationType.xsd #####

-->
	<xs:complexType name="ReminderCustomizationType">
		<xs:annotation>
			<xs:documentation>
				Specifies how to return certain reminder types from the user's My eBay account.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="DurationInDays" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							(in) The length of time the reminder has existed in the user's My eBay account,
							in days. Valid values are 1-60.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Include" type="xs:boolean" minOccurs="0">
				<xs:annotation>
						<xs:documentation>
								(in) Whether to include information about this type of reminder in the response.
								When true, the container is returned with default input parameters.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/RemindersType.xsd #####

-->
	<xs:complexType name="RemindersType">
	 <xs:annotation>
			<xs:documentation>
				Specifies the type of reminders for which you want information.
			</xs:documentation>
	 </xs:annotation>
		<xs:sequence>
			<xs:element name="PaymentToSendCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders requesting that the buyer send payment.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
							<Context>BuyingReminders</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackToReceiveCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders that feedback has not yet been received by the buyer or seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackToSendCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders that feedback has not yet been sent by the buyer or seller.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="OutbidCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders advising the buyer that the buyer has been
						outbid.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
							<Context>BuyingReminders</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentToReceiveCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders that the seller has not yet received a payment.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
							<Context>SellingReminders</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SecondChanceOfferCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders requesting that the seller review second
						chance offers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
							<Context>SellingReminders</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingNeededCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders advising the seller that shipping is
						needed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
							<Context>SellingReminders</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RelistingNeededCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) The number of reminders advising the seller that relisting is needed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayReminders</CallName>
							<Returned>Conditionally</Returned>
							<Context>SellingReminders</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/RequestCategoriesType.xsd #####

-->
	<xs:complexType name="RequestCategoriesType">
		<xs:annotation>
			<xs:documentation> 
		A set of parameters that control the retrieval of categories (not items) 
		that match a search query. In GetSearchResults, at least one child element must 
		be specified in order to retrieve matching categories. If empty or not present, 
		no matching category information is returned. .
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CategoriesOnly" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
				Filter to retrieve matching categories but not matching items or buying guides. 
				If true, only matching categories are returned (with no item or buying guide details). 
				If false or not present, matching items and matching categories are both returned, 
				along with buying guide details (if any). 
				If TotalOnly and Categories.CategoriesOnly are both specified
				in the request and their values are inconsistent with each other, 
				TotalOnly overrides Categories.CategoriesOnly.
				That is, if TotalOnly is true and Categories.CategoriesOnly is false, 
				the results include matching categories but no item data or buying guides.
				If TotalOnly is false and Categories.CategoriesOnly is true, the results
				include matching categories, item data, and buying guides.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxCategories" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Maximum quantity of matching categories to return at the first level of the 
            category hierarchy (CategoryLevel 1). 
					</xs:documentation>
					<xs:appinfo>
						<Default>3</Default>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxSubcategories" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Maximum quantity of matching subcategories to return at each lower level 
            of the hierarchy.  
					</xs:documentation>
					<xs:appinfo>
						<Default>3</Default>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Levels" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Filter to control the deepest matching category level to return. 
            If you specify 0, no category data is returned. If you specify a negative number, 
            the results are unpredictable.
					</xs:documentation>
					<xs:appinfo>
						<Default>2</Default>
						<Min>1</Min>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ResponseAttributeSetType.xsd #####

-->
	<xs:complexType name="ResponseAttributeSetType">
		<xs:annotation>
			<xs:documentation>
A single set of one or more product families and related information
returned in the results of a product search. Supports Pre-filled Item Information
functionality. See the Developer's Guide for more information about
working with this data.
				</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ApproximatePages" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						The approximate quantity of pages of results that match the product search query
               (TotalProducts divided by the median number of products per page examined so far).
               Always returned when AttributeSet is returned.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               For GetProductFamilyMembers, only returned with compatibility level 415 and higher.
               With lower compatibility levels, ProductSearchResult.ApproximatePages is returned instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
							<Min>1</Min>
							<Max/>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AttributeSetID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
					Numeric value that identifies the attribute set in a language-independent way.
               Unique across all eBay sites. Corresponds to a characteristic set associated
               with the current set of search results.
               Always returned when AttributeSet is returned.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               For GetProductFamilyMembers, only returned with compatibility level 415 and higher.
               With lower compatibility levels, ProductSearchResult.AttributeSetID is returned instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HasMore" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
					If true, the query results contain additional pages (higher than the current page number).
					You can retrieve more results by incrementing the PageNumber value that was passed in the request.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               For GetProductFamilyMembers, only returned with compatibility level 415 and higher.
               With lower compatibility levels, ProductSearchResult.HasMore is returned instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFamilies" type="ns:ProductFamilyType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						ProductFamilies represents one product family. Multiple ProductFamilies
               properties can be returned. A product family identifies a group of related products.
               For example, the movie "My Favorite Movie: The Sequel" might be released on DVD, but there
               might be several editions of the DVD (e.g., in different languages) with different ISBN numbers.
               All variations are part of the same product family ("My Favorite Movie: The Sequel" in the DVD format).
               See "Limit the Quantity of Products Returned Per Family" in the eBay Web Services Guide.
               Always returned when AttributeSet is returned.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               For GetProductFamilyMembers, only returned with compatibility level 415 and higher.
               With lower compatibility levels, ProductSearchResult.ProductFamilies is returned instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderConstraints" type="ns:ProductFinderConstraintType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					A list of attributes (constraints) that were specified in the search request.
               This information is useful when multiple queries were specified in a
               GetProductSearchResults request. Use this information to map each query
               to each result in the response object.
               Applicable when the search request was constructed based on a product finder.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               With lower compatibility levels, ProductSearchResult.ProductFinderConstraints is returned instead.
               Not applicable to GetProductFamilyMembers.
               </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TooManyMatchesFound" type="xs:boolean">
				<xs:annotation>
					<xs:documentation>
						If too many search results match the query, the TooManyMatchesFound tag is returned
            with a value of true, and a warning is returned.
            If this occurs, it may be a good idea to ask the user to specify more details to narrow the search
            (e.g., specify "My Favorite Movie" instead of "My").
            For GetProductSearchResults, only returned with compatibility level 387 and higher.
            With lower compatibility levels, ProductSearchResult.TooManyMatchesFound is returned instead.
						Returns false for GetProductFamilyMembers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalProducts" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						The total quantity of products that match the query (within
               the characteristic set). This can exceed the actual number
               of products returned in the current virtual page. Always returned when AttributeSet is returned.
               For GetProductSearchResults, only returned with compatibility level 387 and higher.
               For GetProductFamilyMembers, only returned with compatibility level 415 and higher.
               With lower compatibility levels, ProductSearchResult.TotalProducts is returned instead.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ReviseStatusType.xsd #####

-->
	<xs:complexType name="ReviseStatusType">
		<xs:annotation>
			<xs:documentation> 
        Contains data indicating whether an item has been revised since the
        listing became active and, if so, which among a subset of properties
        have been changed by the revision.
        Output only.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemRevised" type="xs:boolean">
				<xs:annotation>
					<xs:documentation> 
            If true, indicates the item was revised since the listing became
            active.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>							
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyItNowAdded" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            If true, indicates that a Buy It Now Price was added for the item.
            Only applicable to US eBay Motors items.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyItNowLowered" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            If true, indicates that the item's Buy It Now price was lowered.
            Only applicable to US eBay Motors items.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReserveLowered" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            If true, indicates that the reserve price was lowered for
            the item. Only applicable to US eBay Motors items.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReserveRemoved" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            If true, indicates that the reserve price was removed
            from the item. Only applicable to US eBay Motors items.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SIFFTASRecommendationsType.xsd #####

-->
	<xs:complexType name="SIFFTASRecommendationsType">
		<xs:annotation>
			<xs:documentation> 
	         Reserved for future use..
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AttributeSetArray" type="ns:AttributeSetArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SKUArrayType.xsd #####

-->
	<xs:complexType name="SKUArrayType">
		<xs:annotation>
			<xs:documentation>
				A list of stock-keeping unit (SKU) identifiers that a seller uses in listings.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SKU" type="ns:SKUType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Identifier defined and used by a seller to identify an item. The
						seller can use a SKU to identify one item or use the same SKU for
						multiple items. Preferable to ApplicationData for SKUs and inventory
						tracking. Different sellers can use the same SKUs. This element can
						be used by sellers to track complex flows of products and
						information. This element preserves a SKU, enabling a seller to
						obtain it before and after a transaction is created.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>50</MaxLength>
						<CallInfo>
							<CallName>GetSellerTransactions</CallName>
							<CallName>GetSellerList</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SKUType.xsd #####

-->
	<xs:simpleType name="SKUType">
		<xs:annotation>
			<xs:documentation>
        Type that represents a stock-keeping unit (SKU). The seller can use a
				SKU to identify one item or use the same SKU for multiple items.
				Preferable to ApplicationData for SKUs and inventory tracking. Different
				sellers can use the same SKUs. This element can be used by sellers to
				track complex flows of products and information. This element preserves
				a SKU, enabling a seller to obtain it before and after a transaction is
				created.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SMSSubscriptionErrorCodeCodeList.xsd #####

-->
	<xs:simpleType name="SMSSubscriptionErrorCodeCodeType">
		<xs:annotation>
			<xs:documentation>
				Type of SMS subscription error.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="SMSAggregatorNotAvailable">
				<xs:annotation>
					<xs:documentation>
						Aggregator not available.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PhoneNumberInvalid">
				<xs:annotation>
					<xs:documentation>
						Phone number invalid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PhoneNumberChanged">
				<xs:annotation>
					<xs:documentation>
						Phone number has changed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PhoneNumberCarrierChanged">
				<xs:annotation>
					<xs:documentation>
						The carrier has changed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UserRequestedUnregistration">
				<xs:annotation>
					<xs:documentation>
						The user has requested to be unregistered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SMSSubscriptionType.xsd #####

-->
	<xs:complexType name="SMSSubscriptionType">
		<xs:annotation>
			<xs:documentation>
				(in/out) User data related to notifications.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SMSPhone" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The wireless phone number to be used for receiving SMS messages.
						Max length of phone number varies by country.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>varies by country</MaxLength>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserStatus" type="ns:SMSSubscriptionUserStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Registered/Unregistered/Pending.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CarrierID" type="ns:WirelessCarrierIDCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The wireless carrier ID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ErrorCode" type="ns:SMSSubscriptionErrorCodeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reason for SMS subscription error (postback from thired-party integrator).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemToUnsubscribe" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID of item to unsubscribe from SMS notification.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SiteInfo>
							<TheseSites>CN</TheseSites>
						</SiteInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SMSSubscriptionUserStatusCodeList.xsd #####

-->
	<xs:simpleType name="SMSSubscriptionUserStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				The current state of user SMS subscription.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Registered">
				<xs:annotation>
					<xs:documentation>
						(in) Registered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Unregistered">
				<xs:annotation>
					<xs:documentation>
						(in) Unregistered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						(in) Pending subscription.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Failed">
				<xs:annotation>
					<xs:documentation>
						(in) Subscription failed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SalesTaxType.xsd #####

-->
	<xs:complexType name="SalesTaxType">
		<xs:annotation>
			<xs:documentation>
        Type for expressing sales tax data.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SalesTaxPercent" type="xs:float" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Percent of an item's price to be charged as the sales
						tax for the transaction. The value passed in is stored with a
						precision of 3 digits after the decimal point (##.###).
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>SendInvoice</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetTaxTable</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SalesTaxState" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            State or jurisdiction for which the sales tax is being collected.
            Also returned for Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>SendInvoice</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingIncludedInTax" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            (US only) Whether shipping costs were part of the base amount
            that was taxed. Flat or calculated shipping.
            Also returned for Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>SendInvoice</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SalesTaxAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(US only) The amount of sales tax.
						Also returned for Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ScheduleType.xsd #####

-->
	<xs:complexType name="ScheduleType">
		<xs:annotation>
			<xs:documentation> 
Sellers create live auction catalogs and schedule their live auction events by using the 
eBay Live Auctions Web site user interface. The seller can create a catalog in the Live Auctions 
system several months before a sale. 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ScheduleID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            	Identifier for an event schedule in the seller's Live Auctions catalog. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionCatalogDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ScheduleTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            	Date and time that the sale schedule starts.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetLiveAuctionCatalogDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SchedulingInfoType.xsd #####

-->
	<xs:complexType name="SchedulingInfoType">
		<xs:annotation>
			<xs:documentation> 
        Contains information for scheduling limits for the user.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MaxScheduledMinutes" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Maximum number of minutes that a listing may be scheduled in advance of its going live.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinScheduledMinutes" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Minimum number of minutes that a listing may be scheduled in advance of its going live.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxScheduledItems" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Maximum number of Items that a user may schedule.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchAttributesType.xsd #####

-->
	<xs:complexType name="SearchAttributesType">
		<xs:annotation>
			<xs:documentation>
      A product or item aspect or feature that can be used as a criterion in a search 
      for catalog content or for listed items. 
      For example, "Format" might be a criterion for searching the catalogs for 
      Pre-filled Item Information related to hardcover books. 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AttributeID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
            Unique identifier for the attribute within the characteristic set.
            Required if SearchAttributes is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DateSpecifier" type="ns:DateSpecifierCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Specifies the date sub-component that the attribute represents.
						This only applies to date attributes. Required when searching by date attributes.
            Allows for separate text fields or drop-down lists to be rendered for
            each sub-component. For example, the day, month, and year can be rendered as
            separate drop-down lists. See DateSpecifierCodeType for possible values.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RangeSpecifier" type="ns:RangeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Indicates that the attribute represents the high or low end in a range,
						such as a date range or a price range. Required when searching on ranges.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ValueList" type="ns:ValType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Container for the list of one or more valid values that the user has selected for 
            the searchable attribute. If multiple values are specified, the search engine 
            applies "OR" logic to the query (i.e., at least one of the specified values must match).
            Required if SearchAttributes is specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetProductSearchResults</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchDetailsType.xsd #####

-->
	<xs:complexType name="SearchDetailsType">
		<xs:sequence>
			<xs:element name="BuyItNowEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether a listing uses the Buy It Now feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Picture" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
          Indicates whether a listing has an image associated with it.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RecentListing" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Indicates whether a listing is no more than one day old.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchFlagsCodeList.xsd #####

-->
	<xs:simpleType name="SearchFlagsCodeType">
		<xs:annotation>
			<xs:documentation>
           SearchFlagsCodeType - Search flags for GetSearchResults.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Charity">
				<xs:annotation>
					<xs:documentation>
                Return only charity item listings.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SearchInDescription">
				<xs:annotation>
					<xs:documentation>
                Include the description field of item listings in keyword search. Item
                listings returned are those where specified search keywords appear in
                the description, as well as the title and sub-title.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PayPalBuyerPaymentOption">
				<xs:annotation>
					<xs:documentation>
                Return only item listings where PayPal is a payment method offered by the
                seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NowAndNew">
				<xs:annotation>
					<xs:documentation>
               (in) Return only items that have been listed with Now and New. Applicable for 
               certain sites only. See the Developer's Guide.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SearchLocationFilterType.xsd #####

-->
	<xs:complexType name="SearchLocationFilterType">
		<xs:annotation>
			<xs:documentation> 
        One of the data filters used when searching for items using
        GetSearchResults. Allows filtering based on an item's location (where
        the seller would be shipping the item from) or an item's availability
        (which eBay sites the item can be purchased from).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CountryCode" type="ns:CountryCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Country the item is either located in or available to (depending on the value
            specified in ItemLocation).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemLocation" type="ns:ItemLocationCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Specifies whether the filter should be for items located in the country
            specified in Country or available to that country.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchLocation" type="ns:SearchLocationType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Specifies filtering based on site ID.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Currency" type="ns:CurrencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchLocationType.xsd #####

-->
	<xs:complexType name="SearchLocationType">
		<xs:annotation>
			<xs:documentation> 
				One of the data filters used when searching for items using
				GetSearchResults. Allows filtering based on the location of the item or
				its availability relative to an eBay site. Or allows for filtering
				based on regional listing.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="RegionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies a region ID. The item must have been listed for the specified region
						to be returned in the search result set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteLocation" type="ns:SiteLocationType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Specifies a filter based on a particular eBay site and the 
            item's relation to
            that site (items listed with a site's currency, items located 
            in the country
            for the site, items available to the country for the site, and 
            items listed
            on the specified site).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchRequestType.xsd #####

-->
	<xs:complexType name="SearchRequestType">
		<xs:annotation>
			<xs:documentation>
      Specifies a query consisting of attributes. Only attributes that are returned 
      from GetProductFinder can be used. See the Developer's Guide for more information.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AttributeSetID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
            Numeric identifier for a characteristic set that defines the attributes
            (unique across all eBay sites). 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductFinderID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Numeric identifier for a buy-side product finder. A product finder defines how to 
            search for Item Specifics in listings (e.g., how to search against a particular shoe size).
            See the eBay Web Services guide for details about product finders.
            You need to specify a product finder ID when you are searching against a listing's 
            Item Specifics (i.e., when you use SearchAttributes).
				A few categories, such as US Event Tickets and US eBay Motors, can also return a subset of Item Specifics 
				(e.g., the event venue, section, and row for a ticket listing) in the search results. 
				To retrieve this data, you must specify the product finder ID, and also specify a detail level of
				ItemReturnAttributes or ReturnAll. Use GetProductFinder to determine valid product finder IDs.
					</xs:documentation>
						<xs:appinfo>
							<CallInfo>
								<CallName>GetSearchResults</CallName>
								<RequiredInput>Conditionally</RequiredInput>
							</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchAttributes" type="ns:SearchAttributesType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            A query consisting of a set of attributes (search criteria). If the query 
            includes multiple attributes, the search engine will apply "AND" logic to the 
            query. Use GetProductFinder to determine the list of valid attributes 
            and how many are permitted for the specified characteristic set.
            If specified, ProductFinderID must also be specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchResultItemArrayType.xsd #####

-->
	<xs:complexType name="SearchResultItemArrayType">
		<xs:annotation>
			<xs:documentation> 
        Container for a list of search result items, such as returned by
        GetSearchResults. Will contain zero, one, or multiple
        SearchResultItemType items, each of which represents one item listing
        that was found by the search.
        Output only.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SearchResultItem" type="ns:SearchResultItemType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
            Contains data for an item listing found by a search.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchResultItemType.xsd #####

-->
	<xs:complexType name="SearchResultItemType">
		<xs:annotation>
			<xs:documentation> 
        Contains the data for one item listing found by a search (such as by
        GetSearchResults).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Item" type="ns:ItemType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Contains summary data for the item listing itself, with the properties that define
            the listing. For all item data, use an item-retrieval call, such as GetItem.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemSpecific" type="ns:NameValueListArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            A list of attribute and value pairs. GetSearchResults can return this
            when the request either specifies IncludeCondition as true or specifies a product finder 
            search by using SearchRequest.
            If IncludeCondition was true, this returns the item condition (e.g., New).
            If SearchRequest was used to perform a product finder search, the list 
            is limited to attributes that would be included in the 
            summary search results on the Web site, if any. In some categories, 
            no summary attributes are returned in search results (even when the item 
            is listed with Item Specifics.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchResultValues" type="ns:SearchResultValuesCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
            Contains additional information about the item listing returned in Item. This
            information includes whether the item has an image associated with it, 
            and more. May contain zero, one, or multiple SearchResultValuesCodeType 
            values indicating different pieces of additional information about 
            the listing. These values are analogous to the icons that appear in an 
            item listing's line in a Search page.
            Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchResultValuesCodeList.xsd #####

-->
	<xs:simpleType name="SearchResultValuesCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Escrow">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="New">
				<xs:annotation>
					<xs:documentation>
            (out) Indicates items listed one day or less earlier than the current query. 
            If the listing is no more than one day old, New returns a value of true. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CharityListing">
				<xs:annotation>
					<xs:documentation>
            (out) Indicates that the seller has chosen to use eBay Giving Works to donate 
            a percentage of the item purchase price to a selected nonprofit organization. 
            Not applicable for eBay Motors, international sites, and Real Estate and Tickets listings. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Picture">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Gift">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SearchSortOrderCodeList.xsd #####

-->
	<xs:simpleType name="SearchSortOrderCodeType">
		<xs:annotation>
			<xs:documentation>
				Determines the order in which items are returned when you use the GetSearchResults call.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="SortByEndDate">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items by the end date (items ending soonest). This is the default for most sites,
						except where noted for other values.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByStartDate">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items by the start date (most recently listed first).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByCurrentBid">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items by CurrentPrice (lowest bid first).
						Note that if an item was listed in a different currency from the
						site's currency, that item is sorted is based on its ConvertedCurrentPrice value.
						(It is a good idea to use SortByCurrentBidAsc instead.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByListingDate">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items by the listing date in descending order.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByCurrentBidAsc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items by the current bid price in ascending order (lowest bid first).
						Note that if an item was listed in a different currency from the
						site currency, the item is sorted based on its ConvertedCurrentPrice value.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByCurrentBidDesc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items by the current bid price in descending order (highest bid first).
						Note that if an item was listed in a different currency from the
						site's currency, the item is sorted based on its ConvertedCurrentPrice value.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByPayPalAsc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items in ascending order based on whether PayPal is accepted (accepted followed by unaccepted).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByPayPalDesc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items in descending order based on whether PayPal is accepted (unaccepted followed by accepted).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByEscrowAsc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items in ascending order based on whether Escrow is applicable (applicable followed by inapplicable).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByEscrowDesc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items in descending order based on whether Escrow is applicable (inapplicable followed by applicable).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByCountryAsc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items in ascending order by the country in which the items are located.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByCountryDesc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items in descending order by the country in which the items are located.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByDistanceAsc">
				<xs:annotation>
					<xs:documentation>
						(in) Sorts items based on distance from the buyer, with the nearest items returned first.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByBidCountAsc">
				<xs:annotation>
					<xs:documentation>
					(in) Sorts items based on the number of bids, fewest bids first.
					Applicable to China and Taiwan sites only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SortByBidCountDesc">
				<xs:annotation>
					<xs:documentation>
					(in) Sorts items based on the number of bids, most bids first.
					Applicable to China and Taiwan sites only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SearchStoreFilterType.xsd #####

-->
	<xs:complexType name="SearchStoreFilterType">
		<xs:annotation>
			<xs:documentation> 
        One of the data filters used when searching for items using
        GetSearchResults. Allows filtering based on an item's appearing in a
        specific eBay Store.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="StoreName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Name of the eBay Store the item must be listed in.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StoreSearch" type="ns:StoreSearchCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
            Specifies the type of store search used in the filtering: one eBay Store (name
            specified in StoreName) or all eBay stores, and also by listing type. Possible
            values are enumerated in the StoreSearchCodeType code list.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SearchTypeCodeList.xsd #####

-->
	<xs:simpleType name="SearchTypeCodeType">
		<xs:annotation>
			<xs:documentation>
           SearchTypeCodeType - Type declaration to be used by other schema.
           Identifies the SearchTypes (e.g., for GetSearchResults requests)
           used to restrict items returned to: only Gallery items or gallery
           and non-Gallery items.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="All">
				<xs:annotation>
					<xs:documentation>
                (in) Return Gallery and non-Gallery item listings.
				      </xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Gallery">
				<xs:annotation>
					<xs:documentation> 
                (in) Return Gallery items only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SecondChanceOfferDurationCodeList.xsd #####

-->
	<xs:simpleType name="SecondChanceOfferDurationCodeType">
		<xs:annotation>
			<xs:documentation>
           SecondChanceOfferDurationCodeType - Type declaration to be used by
           other schema. Specifies the number of days the second chance offer
           active. The recipient bidder must purchase the item within that time
           or the listing expires. The duration for a new second chance offer
           listing is limited to these values.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Days_1">
				<xs:annotation>
					<xs:documentation>
                (in) 1 Day.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_3">
				<xs:annotation>
					<xs:documentation>
                (in) 3 Days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_5">
				<xs:annotation>
					<xs:documentation>
                (in) 5 Days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Days_7">
				<xs:annotation>
					<xs:documentation>
                (in) 7 Days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SelectionModeCodeList.xsd #####

-->
	<xs:simpleType name="SelectionModeCodeType">
		<xs:annotation>
			<xs:documentation>
						This is automatic or manual depending on selection.
					</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="Automatic">
				<xs:annotation>
					<xs:documentation>
               Automatic criteria
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Manual">
				<xs:annotation>
					<xs:documentation>
               Manual criteria
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SellerBusinessCodeTypeList.xsd #####

-->
	<xs:simpleType name="SellerBusinessCodeType">
			<xs:annotation>
				<xs:documentation>
					Type of seller account. This value can be returned if the German site (site ID 77) or eBay Motors site (site ID 100) is specified.
				</xs:documentation>
			</xs:annotation>
			<xs:restriction base="xs:token">
				<xs:enumeration value="Undefined">
					<xs:annotation>
						<xs:documentation>
							Type of seller account not defined.
						</xs:documentation>
					</xs:annotation>
				</xs:enumeration>
				<xs:enumeration value="Private">
					<xs:annotation>
						<xs:documentation>
							Private seller account.
						</xs:documentation>
					</xs:annotation>
				</xs:enumeration>
				<xs:enumeration value="Commercial">
					<xs:annotation>
						<xs:documentation>
							Commercial seller account.
						</xs:documentation>
					</xs:annotation>
				</xs:enumeration>
			</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SellerContactDetailsEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="SellerContactDetailsEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation>
				Reserved for future use.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellerFavoriteItemPreferencesType.xsd #####

-->
	<xs:complexType name="SellerFavoriteItemPreferencesType">
		<xs:annotation>
			<xs:documentation> 
				Contains the data for the seller favorite item preferences, i.e.  the manual or automatic selection criteria to display items for buyer's favourite seller opt in email marketing.  
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SearchKeywords" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The keywords in the item title for the automatic item search criteria.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StoreCategoryID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(For eBay Store owners only) The store custom category for the  automatic item search criteria.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingType" type="ns:ListingTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The listing format (fixed price, auction, etc) for the automatic item search criteria.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchSortOrder" type="ns:StoreItemListSortOrderCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The sort order chosen from the standard ebay sorts for the automatic search criteria.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the lower limit of price range for the automatic search criteria.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MaxPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the upper limit of price range for the automatic search criteria.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FavoriteItemID" type="ns:ItemIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Specifies the list of favorite items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellerGuaranteeLevelCodeList.xsd #####

-->
	<xs:simpleType name="SellerGuaranteeLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				Maximum level of guarantee a seller is authorized to offer.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NotEligible">
				<xs:annotation>
					<xs:documentation>
						(out) Not eligible for Seller Level Guarantee
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Regular">
				<xs:annotation>
					<xs:documentation>
						(out) Regular eligibility level
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Premium">
				<xs:annotation>
					<xs:documentation>
						(out) Premium eligibility level
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Ultra">
				<xs:annotation>
					<xs:documentation>
						(out) Ultra eligibility level
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SellerLevelCodeList.xsd #####

-->
	<xs:simpleType name="SellerLevelCodeType">
		<xs:annotation>
			<xs:documentation>
SellerLevelCodeType - Type declaration to be used by other schema.
Indicates the user's eBay PowerSeller tier.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Bronze">
				<xs:annotation>
					<xs:documentation>
						(out) Bronze
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Silver">
				<xs:annotation>
					<xs:documentation>
						(out) Silver
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Gold">
				<xs:annotation>
					<xs:documentation>
						(out) Gold
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Platinum">
				<xs:annotation>
					<xs:documentation>
						(out) Platinum
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Titanium">
				<xs:annotation>
					<xs:documentation>
						(out) Titanium
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(out) None
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SellerPaymentMethodCodeList.xsd #####

-->
	<xs:simpleType name="SellerPaymentMethodCodeType">
		<xs:annotation>
			<xs:documentation>
SellerPaymentMethodCodeType - Type declaration to be used by other schema.
These are payment methods that sellers can use to pay eBay fees.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NothingOnFile">
				<xs:annotation>
					<xs:documentation>
						    Used for all other payment methods (e.g., payment via PayPal) which are not specifically listed in other columns.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCard">
				<xs:annotation>
					<xs:documentation>
						    Credit Card
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebit">
				<xs:annotation>
					<xs:documentation>
						    Direct Debit
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DirectDebitPendingSignatureMandate">
				<xs:annotation>
					<xs:documentation>
						   Direct Debit, pending signature mandate
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayDirectPay">
				<xs:annotation>
					<xs:documentation>
						   eBay Direct Pay
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SellerPaymentPreferencesType.xsd #####

-->
	<xs:complexType name="SellerPaymentPreferencesType">
		<xs:annotation>
			<xs:documentation>
			  Defines the values that make up the seller's preferences.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AlwaysUseThisPaymentAddress" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the seller wants all transactions
						with eBay to use the address specified in SellerPaymentAddress.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplayPayNowButton" type="ns:DisplayPayNowButtonCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Determines whether the Pay Now button should always be displayed 
						for the user's listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalPreferred" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether a seller wants to let buyers know that PayPal payments
						are preferred.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DefaultPayPalEmailAddress" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default email address the seller uses for receiving PayPal payments.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalAlwaysOn" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether PayPal is always accepted for the seller's listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerPaymentAddress" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the address the seller uses to receive payments from buyers.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UPSRateOption" type="ns:UPSRateOptionCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the type of United Postal Service rates to use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUserPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetUserPreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellerPaymentType.xsd #####

-->
	<xs:complexType name="SellerPaymentType">
		<xs:annotation>
			<xs:documentation>
				A payment between Half.com and a seller. The financial value of a payment is
				typically based on an amount that a buyer paid to Half.com for a transaction, plus
				the shipping cost the buyer paid for the item, minus Half.com's commission. Each
				payment is for one transaction for one item in one order.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ItemID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID of the Half.com item associated with the payment.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>19 (Note: The eBay database specifies 38. Currently, Item IDs are usually 9 to 12 digits)</MaxLength>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID of the Half.com transaction associated with the payment.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="OrderID" type="ns:OrderIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						ID of the Half.com order associated with the payment.
						Returns 0 for single-transaction orders.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerInventoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						An ID that the seller specified when they listed the Half.com item, if any. It
						can be used for the seller's SKU. Note that SellerInventoryID is not returned
						if no ID was specified. (Note: The SKU field used for eBay.com listings is not
						applicable to Half.com listings.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrivateNotes" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A text note that the seller specified for the Half.com item, if any. Only
						visible to the seller. Not returned if the seller specified no notes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalProductID" type="ns:ExternalProductIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains an ISBN, UPC, or EAN value from the catalog product associated with
						the Half.com item. All Half.com items are listed with Pre-filled Item
						Information.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The title of the listing, as it appears on Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentType" type="ns:PaymentTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the payment is for a Half.com sale or a refund.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Price of the transaction specified by TransactionID (before shipping and other
						costs).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingReimbursement" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The adjusted shipping cost that Half.com pays the seller. If multiple items
						from the same seller are in the same order, this amount may be less than the
						rate for shipping the item individually. This amount may also be adjusted due
						to Half.com handling charges. (Due to the way shipping costs are calculated,
						this value may be different for identical items in different orders.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Commission" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Amount of commission charged by Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AmountPaid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Payment amount made by buyer for the Half.com transaction.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaidTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The time and date when Half.com created the payment. This time is specified in
						GMT (not Pacific time). See "Time Values" in the eBay Web Services guide for
						information about converting between GMT and other time zones A payment is
						created when the buyer pays for an order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerPayments</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellerType.xsd #####

-->
	<xs:complexType name="SellerType">
	<xs:annotation>
		<xs:documentation>
			Information about a user returned in the context of an item's seller.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="PaisaPayStatus" type="xs:int" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Indicates the seller's PaisaPay registration status.&lt;br&gt;
					0 - Seller not registered&lt;br&gt;
					1 - Seller registered&lt;br&gt;
					2 - Seller registered but registration suspended&lt;br&gt;
					3 - Seller registered but outbound payment suspended&lt;br&gt;
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="AllowPaymentEdit" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Indicates whether the user as a seller by default allows buyers to edit the
					total cost of an item (while in checkout). (Sellers enable this property in
					their My eBay user preferences on the eBay site.)
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="BillingCurrency" type="ns:CurrencyCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Currency type in which the user is billed seller fees.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CheckoutEnabled" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Indicates whether the user as a seller has the option set to default new
					item listings to go through checkout. (Sellers enable this property in
					their My eBay user preferences on the eBay site.)
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CIPBankAccountStored" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					If true, indicates that the user has stored bank account information with eBay
					in order to use the "CIP in checkout" feature. Applicable to all eBay sites
					that support CIP as a payment method.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="GoodStanding" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					If true, indicates that the user is in good standing with eBay. (One of the
					requirements for listing a new item with Immediate Payment.)
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="LiveAuctionAuthorized" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					If true, the user is authorized to list lot items to the eBay Live Auctions
					site.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="MerchandizingPref" type="ns:MerchandizingPrefCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Indicates whether the seller participates in the
					Merchandising Manager feature. If so, the seller can
					set up rules for cross-promoting items from the seller's store.
					If not, eBay cross-promotes items as the seller's items are
					being viewed or purchased.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="QualifiesForB2BVAT" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Indicates whether the user is subject to VAT. Users who have registered with
					eBay as VAT-exempt are not subject to VAT.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SellerGuaranteeLevel" type="ns:SellerGuaranteeLevelCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Maximum level of Motor's Seller guarantee the seller is authorized to offer.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SellerLevel" type="ns:SellerLevelCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The user's eBay PowerSeller tier. Possible values are enumerated in the
					SellerLevelCodeType code list.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SellerPaymentAddress" type="ns:AddressType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Address used by eBay for purposes of billing the user for seller fees.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SchedulingInfo" type="ns:SchedulingInfoType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Container for scheduling limits for the user. Conveys the minimum and maximum
					minutes the user may schedule listings in advance, as well as the maximum
					number of items the user may schedule.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="StoreOwner" type="xs:boolean">
			<xs:annotation>
				<xs:documentation>
					Indicates whether the user has an eBay Store (boolean value).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<CallName>GetBidderList</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="StoreURL" type="xs:anyURI" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					URL for the user's eBay Store, if the user is a Store owner. Blank if not.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetAllBidders</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<DetailLevels>none, ReturnAll</DetailLevels>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<Context>SellerInfo</Context>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SellerBusinessType" type="ns:SellerBusinessCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Type of seller account. This value can be returned if the German site (site ID 77) or eBay Motors site (site ID 100) is specified.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
				<!-- N/A: GetUser -->
			</xs:annotation>
		</xs:element>
		<xs:element name="RegisteredBusinessSeller" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					If true, the user is registered as a vehicle dealer on the eBay Motors site.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ExpressEligible" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					If true, the user is eligible to sell items on eBay Express,
					based on the data available to eBay at the time you execute the call (e.g., GetUser).
					For users registered in the US or Canada, the user is eligible to sell on Express US.
					For users registed in Germany, the user is eligible to sell on Express Germany.
					However, a user can still be disqualified at any time if
					their feedback score changes or some other event occurs
					that would normally disqualify a seller for Express.&lt;br&gt;
					&lt;br&gt;
					If false, the user is not eligible to sell items on Express. In this case,
					you may be able to determine probable causes by examining these fields:&lt;br&gt;
					- User.FeedbackPrivate&lt;br&gt;
					- User.FeedbackScore&lt;br&gt;
					- User.PositiveFeedbackPercent&lt;br&gt;
					- User.RegistrationAddress.CountryName&lt;br&gt;
					- User.Site&lt;br&gt;
					- CombinedPaymentPreferences (in GetUserPreferences)
				</xs:documentation>
				<xs:appinfo>
					<SeeLink>
						<Title>Seller Eligibility Criteria for eBay Express</Title>
						<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ExpressSellerCriteria</URL>
					</SeeLink>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<!-- N/A to GetOrderTransactions -->
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PaymentMethod" type="ns:SellerPaymentMethodCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
				</xs:documentation>
			</xs:annotation>
		</xs:element>
		<xs:element name="ProStoresPreference" type="ns:ProStoresCheckoutPreferenceType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Details about the store and checkout preferences.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ExpressWallet" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
				If true, the seller has an Express wallet, which is used to store information about
				multiple credit cards associated with the seller's account.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<!-- N/A to GetOrderTransactions -->
					<CallInfo>
						<CallName>GetUser</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Always</Returned>
						<Context>Seller</Context>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellingManagerProductDetailsType.xsd #####

-->
	<xs:complexType name="SellingManagerProductDetailsType">
		<xs:annotation>
			<xs:documentation>Returned if the user is a Selling Manager
			Pro user.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ProductName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>The exact product name of an item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PartNumber" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>The numeric part number of an item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProductPartNumber" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>The alphanumeric part number of an item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellingStatusType.xsd #####

-->
	<xs:complexType name="SellingStatusType">
		<xs:annotation>
			<xs:documentation>
				Contains various details about the current status of a listing. These
				values are computed by eBay and cannot be specified at listing time.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BidCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Number of bids placed so far against the item. Only applicable to
						competitive-bidding listings (Chinese and Dutch auctions).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WonList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>UnsoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BidIncrement" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Smallest amount a bid must be above the current high bid. Only applicable
						to competitive-bidding listings (Chinese and Dutch auctions). Returns zero
						(0.00) for Ad type, eBay Stores Inventory (Stores Fixed-price), and Basic
						Fixed-Price (Fixed Price Item) listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedCurrentPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Converted value of the CurrentPrice in the currency of the site that
						returned this response. For active items, refresh the listing's data every 24
						hours to pick up the current conversion rates.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<CallName>PlaceOffer</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>WonList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CurrentPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For competitive-bidding listings (Chinese and Dutch auctions), current minimum
						asking price (start price) or the current highest bid for the item if bids have
						been placed. Shows minimum bid if no bids have been placed on the item. For
						Basic Fixed-Price (FixedPriceItem), Store Inventory (StoresFixedPrice), or Ad
						type (AdType) listings this returns the original price specified when the item
						was listed/re-listed or the revised price if the item was revised.&lt;br&gt;
						&lt;br&gt;
						For GetSearchResultsExpress, this is the current fixed price of the listing, and
						it is always returned when ItemArray.Item is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetDispute</CallName>
							<CallName>GetMyeBay</CallName>
							<CallName>PlaceOffer</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMemberMessages</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BestOfferList</Context>
							<Context>BidList</Context>
							<Context>LostList</Context>
							<Context>WatchList</Context>
							<Context>WonList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>ActiveList</Context>
							<Context>SoldList</Context>
							<Context>UnsoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HighBidder" type="ns:UserType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For auctions that have ended and have a winning bidder, indicates the user who
						is the current high bidder. For Basic Fixed Price (FixedPriceItem) and Store
						Inventory (StoresFixedPrice) listings that have ended, indicates the user who
						purchased the item. Not returned for auctions that have received no bids or
						Fixed Price Item and Stores Fixed-price listings that are still active.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>ActiveList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LeadCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Applicable to Ad type listings only. Indicates how many leads to
						potential buyers are associated with this item. Returns 0 (zero) for listings in
						other formats.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumToBid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Smallest amount the next bid on the item can be. Returns same value as
						Item.StartPrice (if no bids have yet been placed) or CurrentPrice plus
						BidIncrement (if at least one bid has been placed). Only applicable to Chinese and
						Dutch auction listings. Returns null for basic Fixed Price (FixedPriceItem),
						Store Inventory (StoresFixedPrice), and Ad type listings.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<CallName>PlaceOffer</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QuantitySold" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Number of items purchased so far. (Subtract from the value returned in
						the Item.Quantity field to calculate the number of items remaining.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReserveMet" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the reserve price has been met for the listing. Returns
						true if the reserve price was met or no reserve price was specified.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Context>BidList</Context>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>ActiveList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SecondChanceEligible" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Part of the Second Chance Offer feature, indicates whether the seller can
						extend a second chance offer for the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBay</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BidderCount" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Number of bidders for an item. Only applicable to
					competitive-bidding listings (Chinese and Dutch auctions). Only returned
					for the seller of the item.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>ActiveList</Context>
							<Context>UnsoldList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ListingStatus" type="ns:ListingStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies an active or ended listing's status in eBay's processing workflow.
						If a listing ends with a sale (or sales), eBay needs to update the sale details
						(e.g., total price and buyer/high bidder) and the final value fee. This processing
						can take several minutes. If you retrieve a sold item and no details about the buyer/high bidder
						are returned or no final value fee is available, use this listing status information
						to determine whether eBay has finished processing the listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FinalValueFee" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						You are charged a Final Value Fee if your item is sold, ends with a winning bid,
						or is purchased. This fee applies whether or not you actually
						complete the sale with the buyer.
						See the eBay.com Web site online help for more information about the Final Value Fee.&lt;br&gt;&lt;br&gt;
						If the item was a Dutch auction that ended with bids (not Buy It Now purchases),
						the Final Value Fee is returned in Item.SellingStatus.FinalValueFee. For all other
						listing types, including Dutch auctions that end with Buy It Now purchases, the
						Final Value Fee is returned in Transaction.FinalValueFee.&lt;br&gt;&lt;br&gt;
						The Final Value Fee for fixed price format (FixedPriceItem), Store Inventory format (StoresFixedPrice),
						and Dutch listings purchased with Buy It Now is returned by GetSellerTransactions and GetItemTransactions
						on a transaction by transaction basis, regardless of the listing status.
						For all other listing types, including Chinese and Dutch (with no Buy It Now purchases),
						the Final Value Fee is returned when the listing status is Completed.&lt;br&gt;&lt;br&gt;
						If you request a Final Value Fee Credit, the value of Transaction.FinalValueFee will not
						change for the item if a credit is issued. (The credit only appears in the seller's account data.)
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SellingSummaryType.xsd #####

-->
	<xs:complexType name="SellingSummaryType">
		<xs:sequence>
			<xs:element name="ActiveAuctionCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
								The number of listings the user has open.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AuctionSellingCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
								The total number of items the user is currently selling.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AuctionBidCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							The total number of bids made on the user's active listings.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalAuctionSellingValue" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							The total value of all items the user has for sale in all listings.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalSoldCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							The total number of items the user has sold.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalSoldValue" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
								The total monetary value of the items the user has sold.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SoldDurationInDays" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
							The average duration, in days, of all items sold.
					</xs:documentation>
					<xs:appinfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SetUserNotesActionCodeList.xsd #####

-->
	<xs:simpleType name="SetUserNotesActionCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AddOrUpdate">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delete">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShipmentDeliveryStatusCodeList.xsd #####

-->
	<xs:simpleType name="ShipmentDeliveryStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				Status of the delivery.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Created">
				<xs:annotation>
					<xs:documentation>
						Created (default).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DroppedOff">
				<xs:annotation>
					<xs:documentation>
						Dropped off.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InTransit">
				<xs:annotation>
					<xs:documentation>
						In transit.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delivered">
				<xs:annotation>
					<xs:documentation>
						Delivered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Returned">
				<xs:annotation>
					<xs:documentation>
						Returned.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Canceled">
				<xs:annotation>
					<xs:documentation>
						Cancelled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LabelPrinted">
				<xs:annotation>
					<xs:documentation>
						Label printed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShipmentStatusCodeList.xsd #####

-->
	<xs:simpleType name="ShipmentStatusCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Canceled">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShipmentType.xsd #####

-->
	<xs:complexType name="ShipmentType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EstimatedDeliveryDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="InsuredValue" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackageDepth" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Depth dimension of the package needed to ship the item after it is sold.
            For calculated shipping only.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackageLength" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Length dimension of the package needed to ship the item after it is sold.
            For calculated shipping only.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PackageWidth" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Width dimension of the package needed to ship the item after it is sold.
            For calculated shipping only.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalShipmentID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShipmentID" type="xs:long" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PostageTotal" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PrintedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShipFromAddress" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  The address from which the item is being shipped.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingAddress" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The address to which the item is to be shipped.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingCarrierUsed" type="ns:ShippingCarrierCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The shipping carrier used.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingFeature" type="ns:ShippingFeatureCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingPackage" type="ns:ShippingPackageCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The size of the package used to ship the item(s). See ShippingPackageCodeType
            for its possible values. Input.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceUsed" type="xs:token" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The size of the package used to ship the item(s). See ShippingPackageCodeType
            for its possible values. Input.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShipmentTrackingNumber" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="WeightMajor" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            See the documentation regarding "Working with Item Weights".
            The 'unit' attribute can have a value of lbs.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="WeightMinor" type="ns:MeasureType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            See the documentation regarding "Working with Item Weights".
						The 'unit' attribute is optional and assumed to be the
						minor compared to the value of 'unit' in WeightMajor.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemTransactionID" type="ns:ItemTransactionIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeliveryDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Revise only
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="DeliveryStatus" type="ns:ShipmentDeliveryStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Revise only
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="RefundGrantedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Revise only
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="RefundRequestedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Revise only
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:ShipmentStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						TODO probably not needed, why two statuses? - revise only
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ShippingCarrierCodeList.xsd #####

-->
	<xs:simpleType name="ShippingCarrierCodeType">
		<xs:annotation>
			<xs:documentation>
         Identifies a shipping carrier.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="UPS">
				<xs:annotation>
					<xs:documentation>
						(in/out) United Parcel Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPS">
				<xs:annotation>
					<xs:documentation>
						(in/out) U.S. Postal Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DeutschePost">
				<xs:annotation>
					<xs:documentation>
						Deutsche Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DHL">
				<xs:annotation>
					<xs:documentation>
						DHL service
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Hermes">
				<xs:annotation>
					<xs:documentation>
						Hermes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="iLoxx">
				<xs:annotation>
					<xs:documentation>
						iLoxx.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
						Other Postal Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingDetailsType.xsd #####

-->
	<xs:complexType name="ShippingDetailsType">
	<xs:annotation>
		<xs:documentation>
			Type for the shipping-related details for an item or transaction,
			including flat and calculated shipping costs and shipping
			insurance costs.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="AllowPaymentEdit" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Instead of using this tag, see the PaymentEdited tag.
					Originally, the AllowPaymentEdit tag specified whether the seller allows the
					buyer to edit the payment amount for the transaction. (Sellers
					enabled this property in their My eBay user preferences on the
					eBay site.) ShippingDetails.AllowPaymentEdit is no longer being
					populated by calls to GetItemTransactions.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<TagStatus>Deprecated</TagStatus>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						<TagStatus>Deprecated</TagStatus>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<TagStatus>Deprecated</TagStatus>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<TagStatus>Deprecated</TagStatus>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ApplyShippingDiscount" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Whether the seller specifies that a shipping discount is to be
					applied (in the event that an item's transaction is later
					combined with others into a single order).
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>AddOrder</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="CalculatedShippingRate" type="ns:CalculatedShippingRateType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Details pertinent to one or more items for which
					calculated shipping has been offered by the seller, such as
					package dimension and weight and packaging/handling costs.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>Conditionally</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ChangePaymentInstructions" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Whether the seller specified payment and shipping instructions during checkout (for
					example, to update the details of a transaction). Flat and
					calculated shipping.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<!-- N/A to AddItem family of calls -->
					<CallInfo>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InsuranceFee" type="ns:AmountType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Cost of shipping insurance set by the seller. If the
					buyer bought more than one of this item, this is the insurance
					for just a single item. Exception: for GetItemShipping, this is
					proportional to QuantitySold. Value should be greater than 0.00 if InsuranceOption
					is Optional or Required. For flat shipping only.
					Optional as input and only allowed if ChangePaymentInstructions
					is true.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<Default>0.00</Default>
					<Min/>
					<Max/>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>AddOrder</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Always</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InsuranceOption" type="ns:InsuranceOptionCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Whether the seller offers shipping insurance and, if
					so, whether the insurance is optional or required. Flat and
					calculated shipping. Optional as input and only allowed if
					ChangePaymentInstructions is true.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>AddOrder</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
						<Context>Order</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Always</Returned>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
						<Context>Order</Context>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InsuranceWanted" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Whether the buyer selected to pay for insurance offered
					by the seller as an option. This only has a value after the
					buyer has gone through checkout and selected the insurance
					preference.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none</DetailLevels>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PaymentEdited" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Whether the seller allows the buyer to edit the payment amount
					for the transaction. (Sellers enable this property in their My
					eBay user preferences on the eBay site.)
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="PaymentInstructions" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Payment instructions/message from the seller to the
					buyer. Flat and calculated shipping and return policy instructions.
					(Some sites also let you specify a standard return policy by using
					site-wide attributes in addition or instead. See Item.AttributeSet.)
					See the eBay Web Services Guide for information about specifying shipping
					instructions and return policies.
					Characters like &amp; and ' (apostrophe/single quote) count as 5 characters
					each. To remove this value when revising or relisting an item, use DeletedField.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<MaxLength>500 (250 for China and Taiwan)</MaxLength>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SalesTax" type="ns:SalesTaxType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Sales tax details. US site only. Flat and calculated shipping.
					Also applicable to Half.com (for GetOrders).
					If your application normally calculates sales tax without using eBay's tax
					tables, you should understand how purchases via eBay Express will affect the way
					you process payments. For general information about listings on eBay Express,
					see "eBay Express" in the eBay Web Services Guide.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>AddOrder</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none</DetailLevels>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SellerPostalCode" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Deprecated. Will be removed in a future release. Postal code from seller's
					registration address. Not for calculating shipping costs--see
					CalculatedShippingRateType.OriginatingPostalCode.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						<TagStatus>Deprecated</TagStatus>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<Returned>Conditionally</Returned>
						<TagStatus>Deprecated</TagStatus>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
						<TagStatus>Deprecated</TagStatus>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ShippingRateErrorMessage" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					For most applicable calls, returns the words No Error or returns an error
					message related to an attempt to calculate shipping rates. For calculated
					shipping only.
					Not applicable to Half.com.
					&lt;br&gt;
					&lt;br&gt;
					GetSearchResultsExpress returns this when no PostalCode was specified in the
					request and the item was listed with calculated shipping rates. The message text
					explains that a postal code is needed to calculate shipping. Only returned when
					ItemDetails is set to Fine.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSearchResultsExpress</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ShippingRateType" type="ns:ShippingRateTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					A shipping rate scale for shipping through UPS that affects the shipping cost
					calculated for UPS (lower if ShippingRateType is DailyPickup). ShippingRateType
					is only returned if ShippingService is one of the UPS shipping services. For
					calculated shipping only.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<SeeLink>
						<Title>Shipping</Title>
						<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=Shipping</URL>
					</SeeLink>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ShippingServiceOptions" type="ns:ShippingServiceOptionsType" minOccurs="0" maxOccurs="unbounded">
			<xs:annotation>
				<xs:documentation>
					Shipping costs and options related to domestic shipping services offered by the
					seller. Flat and calculated shipping. Required if
					InternationalShippingServiceOption is specified.&lt;br&gt;
					&lt;br&gt;
					If you specify multiple ShippingServiceOptions nodes, the repeating nodes must
					be contiguous. For example, you can insert InternationalShippingServiceOption
					nodes after a list of repeating ShippingServiceOptions nodes, but not between
					them:&lt;br&gt;
					&lt;br&gt;
					&amp;lt;ShippingServiceOptions&amp;gt;...&amp;lt;/ShippingServiceOptions&amp;gt;&lt;br&gt;
					&amp;lt;ShippingServiceOptions&amp;gt;...&amp;lt;/ShippingServiceOptions&amp;gt;&lt;br&gt;
					&amp;lt;ShippingServiceOptions&amp;gt;...&amp;lt;/ShippingServiceOptions&amp;gt;&lt;br&gt;
					&amp;lt;InternationalShippingServiceOption&amp;gt;...&amp;lt;/InternationalShippingServiceOption&amp;gt;&lt;br&gt;
					&amp;lt;InternationalShippingServiceOption&amp;gt;...&amp;lt;/InternationalShippingServiceOption&amp;gt;&lt;br&gt;&lt;br&gt;
					&lt;br&gt;
					&lt;br&gt;
					If you specify ShippingDetails when you revise or relist an item but you omit
					ShippingServiceOptions, eBay will drop the domestic shipping services from the
					listing. This may also have unintended side effects, as other fields that depend
					on this data may be dropped as well. To retain the shipping services and
					dependent fields when you modify other shipping details, it may be simplest to
					specify all ShippingDetails that you still want to include in the
					listing.&lt;br&gt;
					&lt;br&gt;
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>Conditionally</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetMyeBayBuying</CallName>
						<Returned>Conditionally</Returned>
						<Context>BidList</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetMyeBaySelling</CallName>
						<Returned>Conditionally</Returned>
						<Context>ScheduledList</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Conditionally</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none</DetailLevels>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>AddOrder</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<SeeLink>
						<Title>Overview of the XML API Schema</Title>
						<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=SchemaOverview</URL>
						<For>rules regarding repeating instances of a nodes (nodes for which maxOccurs is "unbounded" or is greater than 1)</For>
					</SeeLink>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="InternationalShippingServiceOption" type="ns:InternationalShippingServiceOptionsType" minOccurs="0" maxOccurs="unbounded">
			<xs:annotation>
				<xs:documentation>
					Shipping costs and options related to an international shipping service. If
					used, at least one domestic shipping service must also be provided in
					ShippingServiceOptions.&lt;br&gt;
					&lt;br&gt;
					If you specify multiple InternationalShippingServiceOption nodes, the repeating
					nodes must be contiguous. That is, you cannot insert other nodes between
					InternationalShippingServiceOption nodes.&lt;br&gt;
					&lt;br&gt;
					If you specify ShippingDetails when you revise or relist an item but you omit
					InternationalShippingServiceOption, eBay will drop the international shipping
					services from the listing. This may also have unintended side effects, as other
					fields that depend on this data may be dropped as well. To retain the shipping
					services and dependent fields when you modify other shipping details, it may be
					simplest to specify all ShippingDetails that you still want to include in the
					listing.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>AddOrder</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Conditionally</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none</DetailLevels>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<SeeLink>
						<Title>Overview of the XML API Schema</Title>
						<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=SchemaOverview</URL>
						<For>rules regarding repeating instances of a nodes (nodes for which maxOccurs is "unbounded" or is greater than 1)</For>
					</SeeLink>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ShippingType" type="ns:ShippingTypeCodeType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The shipping cost model offered by the seller. This is not returned for various
					calls since shipping type can be deduced: if a CalculatedShippingRate structure
					is returned by the call, the shipping type is Calculated. Otherwise, it is Flat
					or Freight.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddItem</CallName>
						<CallName>GetItemRecommendations</CallName>
						<CallName>RelistItem</CallName>
						<CallName>ReviseItem</CallName>
						<CallName>VerifyAddItem</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="SellingManagerSalesRecordNumber" type="xs:int" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Applicable to Selling Manager Pro sellers. Also applicable to
					Half.com (for GetOrders). For GetOrders, the Transaction container
					includes this element within ShippingDetails.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Conditionally</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
						<DetailLevels>none</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ThirdPartyCheckout" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Whether checkout for this is to be handled by a
					Third-Party Checkout application. The counterpart in the Add
					family of calls is Item.ThirdPartyCheckout.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>AddOrder</CallName>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<SeeLink>
						<Title>Third Party Checkout</Title>
						<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ThirdPartyCheckout</URL>
					</SeeLink>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="TaxTable" type="ns:TaxTableType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Tax details for a jurisdiction such as a state or province.
					Returns empty in GetItem if no tax table was used.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItem</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetSellerList</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="GetItFast" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Indicates whether the seller has opted the listing into the Get
					It Fast feature. If GetItFast is true and if at least one of
					the domestic shipping services offered by the seller is an
					expedited shipping service, every shipping service offered by
					the seller is considered a Get It Fast service, and the seller
					commits to delivering the item to the buyer-selected shipping
					service within one day.
					Also applicable to Half.com (for GetOrders).
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetBidderList</CallName>
						<CallName>GetItem</CallName>
						<CallName>GetItemShipping</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ReturnAll</DetailLevels>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrders</CallName>
						<Returned>Always</Returned>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
						<Context>Order</Context>
					</CallInfo>
					<CallInfo>
						<CallName>GetOrderTransactions</CallName>
						<Returned>Always</Returned>
						<DetailLevels>none</DetailLevels>
						<Context>Order</Context>
						<ExcludeFromContext>Transaction</ExcludeFromContext>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ShipmentTrackingNumber" type="xs:string" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					Shipment tracking number supplied by the shipping carrier.
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="ShippingServiceUsed" type="xs:token" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The shipping service that actually shipped the item(s).
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetItemTransactions</CallName>
						<CallName>GetSellerTransactions</CallName>
						<Returned>Conditionally</Returned>
						<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:element name="DefaultShippingCost" type="ns:AmountType" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					The default shipping cost for the item.&lt;br&gt;
					&lt;br&gt;
					For GetSearchResults:&lt;br&gt;
					If ShippingType has the value Flat, then the actual shipping cost is shown. If
					ShippingType has the value Free, then zero is shown. If ShippingType has the
					value Calculated, then this tag (DefaultShippingCost) is not shown. If
					ShippingType has the value NotSpecified, then this tag (DefaultShippingCost) is
					not shown. If ShippingType has the value Freight, then this tag
					(DefaultShippingCost) is not shown.
					&lt;br&gt;
					&lt;br&gt;
					In GetSearchResultsExpress:&lt;br&gt;
					If flat or free shipping was specified for the item, then the actual shipping
					cost is shown. If calculated shipping was specified for the item, then this tag
					(DefaultShippingCost) is only shown if PostalCode is specified in the
					GetSearchResultsExpress request. Otherwise, ShippingRateErrorMessage is returned
					with a message that the postal code is required for the shipping calculation.
					Only returned when ItemDetails is set to Fine.
					&lt;br&gt;
					&lt;br&gt;
					Not applicable to Half.com.
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetSearchResultsExpress</CallName>
						<CallName>GetSearchResults</CallName>
						<Returned>Conditionally</Returned>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ShippingFeatureCodeList.xsd #####

-->
	<xs:simpleType name="ShippingFeatureCodeType">
		<xs:annotation>
			<xs:documentation>
				Miscellaneous details of the shipment.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="DeliveryConfirmation">
				<xs:annotation>
					<xs:documentation>
						Confirmation requested.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SignatureConfirmation">
				<xs:annotation>
					<xs:documentation>
						Signature requested upon receipt.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StealthPostage">
				<xs:annotation>
					<xs:documentation>
						Stealth postage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SaturdayDelivery">
				<xs:annotation>
					<xs:documentation>
						Saturday delivery.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
						Other.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotDefined">
				<xs:annotation>
					<xs:documentation>
						Not defined.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingLocationDetailsType.xsd #####

-->
	<xs:complexType name="ShippingLocationDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details about a region or location to which the seller is willing to ship.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ShippingLocation" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Short name or abbreviation for a region (e.g., Asia) or location (e.g. Japan).&lt;br&gt;&lt;br&gt;
						Related field:&lt;br&gt;
						Item.ShippingDetails.InternationalShippingServiceOption.ShipToLocation in AddItem
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Display name of region or location (sometimes more descriptive than the
						ShippingLocation short name).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ShippingOptionCodeList.xsd #####

-->
	<xs:simpleType name="ShippingOptionCodeType">
		<xs:annotation>
			<xs:documentation>
			  Where the seller is willing to ship the item.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="SiteOnly">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller will only ship to a buyer in the same country/region as the
						eBay site the item is listed on.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WorldWide">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller will ship to a buyer anywhere in the world.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SitePlusRegions">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller will ship to a buyer on the same eBay site or in one of the
						specified regions (ShippingRegionCodeType).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WillNotShip">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller will not (or cannot) ship the item to any buyer at any
						location.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingPackageCodeList.xsd #####

-->
	<xs:simpleType name="ShippingPackageCodeType">
		<xs:annotation>
			<xs:documentation>
				(in/out) The nature of the package used to ship the item(s).
				Required for calculated shipping only. Not all package types
				are supported by a specific shipping service (ShippingServiceCodeType).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
 						(in/out) None
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Letter">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Letter
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LargeEnvelope">
				<xs:annotation>
					<xs:documentation>
 						(in/out) LargeEnvelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSLargePack">
				<xs:annotation>
					<xs:documentation>
 						(in/out) USPS Large Package/Oversize 1
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VeryLargePack">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Very Large Package/Oversize 2
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExtraLargePack">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Extra Large Package/Oversize 3
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSLetter">
				<xs:annotation>
					<xs:documentation>
 						(in/out) UPS Letter
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSFlatRateEnvelope">
				<xs:annotation>
					<xs:documentation>
 						(in/out) USPS Flat Rate Envelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PackageThickEnvelope">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Package/thick envelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Roll">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Roll
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Europallet">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Europallet
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OneWayPallet">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Onewaypallet
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BulkyGoods">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Bulky goods
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Furniture">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Furniture
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Cars">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Cars
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Motorbikes">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Motorbikes
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Caravan">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Caravan
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IndustryVehicles">
				<xs:annotation>
					<xs:documentation>
 						(in/out) Industry vehicles
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
 						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingRateTypeCodeList.xsd #####

-->
	<xs:simpleType name="ShippingRateTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				A shipping rate scale for shipping through UPS that
				affects the shipping cost calculated for UPS (lower if
				ShippingRateType is DailyPickup). For calculated shipping only.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="OnDemand">
				<xs:annotation>
					<xs:documentation>
						"On-demand" shipping rate scale.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DailyPickup">
				<xs:annotation>
					<xs:documentation>
						"Daily pickup" shipping rate scale.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingRegionCodeList.xsd #####

-->
	<xs:simpleType name="ShippingRegionCodeType">
		<xs:annotation>
			<xs:documentation>
				Regions to which the seller is willing to ship the item.
				Only applicable if the seller specifies SitePlusRegions for the shipping
				option (ShippingOptionCodeType).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Africa">
				<xs:annotation>
					<xs:documentation>
						(in/out) Africa
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Asia">
				<xs:annotation>
					<xs:documentation>
						(in/out) Asia
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Caribbean">
				<xs:annotation>
					<xs:documentation>
						(in/out) Caribbean
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Europe">
				<xs:annotation>
					<xs:documentation>
						(in/out) Europe
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LatinAmerica">
				<xs:annotation>
					<xs:documentation>
						(in/out) Latin America
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MiddleEast">
				<xs:annotation>
					<xs:documentation>
						(in/out) Middle East
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NorthAmerica">
				<xs:annotation>
					<xs:documentation>
						(in/out) NorthA merica
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Oceania">
				<xs:annotation>
					<xs:documentation>
						(in/out) Oceania (Pacific region other than Asia)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SouthAmerica">
				<xs:annotation>
					<xs:documentation>
						(in/out) South America
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EuropeanUnion">
				<xs:annotation>
					<xs:documentation>
						(in/out) European Union
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="WillNotShip">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller will not ship the item.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Worldwide">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller has specified Worldwide or eBay has
						determined that the specified regions add up to Worldwide.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Americas">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingServiceCodeList.xsd #####

-->
	<xs:simpleType name="ShippingServiceCodeType">
		<xs:annotation>
			<xs:documentation>
				A shipping service used to ship an item. Applications should not depend on the
				completeness of ShippingServiceCodeType. GeteBayDetails will return the complete
				list of shipping services. To check whether a shipping service is domestic or
				international, call GeteBayDetails with a DetailName of ShippingServiceDetails,
				specifying a site in the header. Shipping services with a ShippingServiceID of
				50000 or higher are international, and the other services are domestic, for that
				site.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="UPSGround">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Ground.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPS3rdDay">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS 3rd Day.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPS2ndDay">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS 2nd Day.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSNextDay">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Next Day.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSPriority">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Priority.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSParcel">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Parcel.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSMedia">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Media.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSFirstClass">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS First Class.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingMethodStandard">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard shipping method.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingMethodExpress">
				<xs:annotation>
					<xs:documentation>
						(in/out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSExpressMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Express Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSNextDayAir">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Next Day Air.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPS2DayAirAM">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Next Day Air.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Other">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other (see description).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocalDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local Delivery/Pickup.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotSelected">
				<xs:annotation>
					<xs:documentation>
						(in/out) Not Selected.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InternationalNotSelected">
				<xs:annotation>
					<xs:documentation>
						(in/out) International Not Selected.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard International Flat Rate Shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Expedited International Flat Rate Shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSGlobalExpress">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Global Express Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSGlobalPriority">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Global Priority Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSEconomyParcel">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Economy Parcel Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSEconomyLetter">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Economy Letter Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSAirmailLetter">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Airmail Letter Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSAirmailParcel">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Airmail Parcel Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpressPlus">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express Plus.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpress">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpedited">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Expedited.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSStandardToCanada">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Standard To Canada.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other International Shipping (see description).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_StandardDispatch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standardversand (unversichert).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_InsuredDispatch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_Writing"/>
			<xs:enumeration value="AT_COD"/>
			<xs:enumeration value="AT_ExpressOrCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Express- oder Kurierversand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_InsuredExpressOrCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Express- oder Kurierversand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_SpecialDispatch"/>
			<xs:enumeration value="AT_InsuredSpecialDispatch"/>
			<xs:enumeration value="AT_Sonstige">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sonstige (Siehe Artikelbeschreibung).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_UnversicherterVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Unversicherter Versand International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_VersicherterVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Versand International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_SonstigerVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sonstiger Versand International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_UnversicherterExpressVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Unversicherter Express Versand International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AT_VersicherterExpressVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Express Versand International
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_Regular">
				<xs:annotation>
					<xs:documentation>
						(in/out) Regular.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_Express">
				<xs:annotation>
					<xs:documentation>
						(in/out) Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_Registered">
				<xs:annotation>
					<xs:documentation>
						(in/out) Registered.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_Courier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_Other">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_EMSInternationalCourierParcels">
				<xs:annotation>
					<xs:documentation>
						(in/out) EMS International Courier - Parcels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_EMSInternationalCourierDocuments">
				<xs:annotation>
					<xs:documentation>
						(in/out) EMS International Courier - Documents.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_ExpressPostInternationalDocuments">
				<xs:annotation>
					<xs:documentation>
						(in/out) Express Post International - Documents.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_AirMailInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Air Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_EconomyAirInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Economy Air.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_SeaMailInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sea Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard International Flat Rate Postage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Expedited International Flat Rate Postage.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AU_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other International Postage (see description).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_StandardDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_PriorityDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_ParcelPost">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_RegisteredMail">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_Other">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_DePostInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) De Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_UPSInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_FedExInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Fedex.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_DHLInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_TPGPostTNTInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) TPG Post/TNT (Netherlands).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Frais de livraison internationale fixes.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Frais fixes pour livraison internationale express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Autres livraisons internationales (voir description).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BEFR_LaPosteInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) La Poste (France).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_StandardDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard Delivery.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_PriorityDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Priority Delivery
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_ParcelPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcel Post
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_RegisteredMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Registered Mail
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_Other">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other Shipping Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_DePostInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) De Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_UPSInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_FedExInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Fedex.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_DHLInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_TPGPostTNTInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) TPG Post/TNT (Netherlands).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Expedited International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other International Shipping Services.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BENL_LaPosteInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) La Poste (France).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_StandardDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard Delivery.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_ExpeditedDelivery"/>
			<xs:enumeration value="CA_PostLettermail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post Lettermail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostRegularParcel">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post Regular Parcel.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostExpeditedParcel">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post Expedited Parcel.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostXpresspost">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostPriorityCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post Priority Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standard International Flat Rate Shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Expedited International Flat Rate Shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other International Shipping (see description).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostExpeditedParcelUSA">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostSmallPacketsUSA">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostXpresspostUSA">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostXpresspostInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostInternationalParcelSurface">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostInternationalParcelAir">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_SmallPacketsInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Small Packets - International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PurolatorInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Purolator International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostSmallPacketsUSAGround">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post Small Packets - USA - Ground.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostSmallPacketsUSAAir">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post Small Packets - USA - Air.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_SmallPacketsInternationalGround">
				<xs:annotation>
					<xs:documentation>
						(in/out) Small Packets - International - Ground.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_SmallPacketsInternationalAir">
				<xs:annotation>
					<xs:documentation>
						(in/out) Small Packets - International - Air.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostUSALetterPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post USA Letter-post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_PostInternationalLetterPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada Post International Letter-post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSExpressCanada">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Express Canada.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSExpressSaverCanada">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Express Saver Canada.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSExpeditedCanada">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Expedited Canada.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSStandardCanada">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Standard Canada.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSExpressUnitedStates">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Express United States.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSExpeditedUnitedStates">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Expedited United States.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPS3DaySelectUnitedStates">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS 3 Day Select United States.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSStandardUnitedStates">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Standard United States.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSWorldWideExpress">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CA_UPSWorldWideExpedited">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Expedited.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_StandardDispatchAPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standardversand (A-Post/Priority).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_StandardDispatchBPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standardversand (B-Post/Economy).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_InsuredDispatch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Versand (z.B. Assurance/Fragile).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_Writing"/>
			<xs:enumeration value="CH_COD"/>
			<xs:enumeration value="CH_ExpressOrCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Express- oder Kurierversand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_InsuredExpressOrCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Express- oder Kurierversand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_SpecialDispatch"/>
			<xs:enumeration value="CH_InsuredSpecialDispatch"/>
			<xs:enumeration value="CH_Sonstige">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sonstige (Siehe Artikelbeschreibung).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_SonstigerVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sonstiger Versand (Siehe Artikelbeschreibung).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_EconomySendungenInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) ECONOMY Sendungen.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_PrioritySendungenInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) PRIORITY Sendungen.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CH_UrgentSendungenInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) URGENT Sendungen.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CN_PersonalDelivery"/>
			<xs:enumeration value="CN_RegularPackage"/>
			<xs:enumeration value="CN_DeliveryCompanyExpress"/>
			<xs:enumeration value="CN_PostOfficeExpress"/>
			<xs:enumeration value="CN_Others"/>
			<xs:enumeration value="CN_FastPostOffice"/>
			<xs:enumeration value="CN_ExpressDeliverySameCity"/>
			<xs:enumeration value="CN_ExpressDeliveryOtherCities"/>
			<xs:enumeration value="CN_StandardInternational"/>
			<xs:enumeration value="CN_ExpeditedInternational"/>
			<xs:enumeration value="CN_OtherInternational"/>
			<xs:enumeration value="CN_CODInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CN_StandardMailingInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CN_RegularLogisticsInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CN_EMSInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CN_OthersInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_StandardDispatch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Unversicherter Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_InsuredDispatch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_Writing"/>
			<xs:enumeration value="DE_COD"/>
			<xs:enumeration value="DE_ExpressOrCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Express- oder Kurierversand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_InsuredExpressOrCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Express- oder Kurierversand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_SpecialDispatch"/>
			<xs:enumeration value="DE_InsuredSpecialDispatch"/>
			<xs:enumeration value="DE_UnversicherterVersand">
				<xs:annotation>
					<xs:documentation>
						(in/out) Unversicherter Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DeutschePostBrief">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deutsche Post Brief.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DHLPostpaket">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL Postpaket.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DHLPackchen"/>
			<xs:enumeration value="DE_DeutschePostWarensendung">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deutsche Post Warensendung.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DeutschePostBuchersendung"/>
			<xs:enumeration value="DE_HermesPaketUnversichert">
				<xs:annotation>
					<xs:documentation>
						(in/out) Hermes Paket (unversichert).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_HermesPaketVersichert">
				<xs:annotation>
					<xs:documentation>
						(in/out) Hermes Paket (versichert).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_IloxxTransportXXL">
				<xs:annotation>
					<xs:documentation>
						(in/out) iloxx Transport XXL.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_IloxxUbernachtExpress"/>
			<xs:enumeration value="DE_IloxxStandard">
				<xs:annotation>
					<xs:documentation>
						(in/out) iloxx Standard.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_Sonstige">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sonstige (Siehe Artikelbeschreibung).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_UnversicherterVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Unversicherter Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_VersicherterVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DHLPostpaketInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL Postpaket International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DHLPackchenInternational"/>
			<xs:enumeration value="DE_SonstigerVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sonstiger Versand (Siehe Artikelbeschreibung).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_UnversicherterExpressVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Unversicherter Express - Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_VersicherterExpressVersandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Versicherter Express - Versand.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DeutschePostBriefLandInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deutsche Post Brief (Land).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_DeutschePostBriefLuftInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deutsche Post Brief (Luft).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_IloxxEuropaInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) iloxx Europa.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="DE_IloxxWorldWideInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) iloxx World Wide.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_CartasNacionalesHasta20">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cartas nacionales hasta 20 gr.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_CartasNacionalesDeMas20"/>
			<xs:enumeration value="ES_CartasInternacionalesHasta20">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cartas internacionales hasta 20 gr.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_CartasInternacionalesDeMas20">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cartas internacionales de mas de 20 gr.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_PaqueteAzulHasta2kg">
				<xs:annotation>
					<xs:documentation>
						(in/out) Paquete Azul (nacional) hasta 2 kg.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_PaqueteAzulDeMas2kg"/>
			<xs:enumeration value="ES_PaqueteInternacionalEconomico"/>
			<xs:enumeration value="ES_Urgente"/>
			<xs:enumeration value="ES_Otros"/>
			<xs:enumeration value="ES_StandardInternational"/>
			<xs:enumeration value="ES_ExpeditedInternational"/>
			<xs:enumeration value="ES_OtherInternational"/>
			<xs:enumeration value="ES_CartasPostalInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Cartas y tarjetas postales internacionales.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_EmsPostalExpressInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Ems postal expres internacional.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ES_EconomyPacketInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Paquete internacional economico.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_ChronoposteInternationalClassic">
				<xs:annotation>
					<xs:documentation>
						(in/out) Chronoposte International Classic.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_ColiposteColissimoDirect">
				<xs:annotation>
					<xs:documentation>
						(in/out) Coliposte Colissimo Direct.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_DHLExpressEuropack">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL Express Europack.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_UPSStandard">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Standard.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_PostOfficeLetter">
				<xs:annotation>
					<xs:documentation>
						(in/out) Lettre.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_PostOfficeLetterFollowed">
				<xs:annotation>
					<xs:documentation>
						(in/out) Lettre avec suivi.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_PostOfficeLetterRecommended"/>
			<xs:enumeration value="FR_ColiposteColissimo">
				<xs:annotation>
					<xs:documentation>
						(in/out) Colissimo.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_ColiposteColissimoRecommended"/>
			<xs:enumeration value="FR_UPSStandardAgainstRefund">
				<xs:annotation>
					<xs:documentation>
						(in/out) Contre remboursement.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_Autre">
				<xs:annotation>
					<xs:documentation>
						(in/out) Autre mode d'envoi de courrier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_Ecopli">
				<xs:annotation>
					<xs:documentation>
						(in/out) Ecopli.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_Colieco"/>
			<xs:enumeration value="FR_AuteModeDenvoiDeColis">
				<xs:annotation>
					<xs:documentation>
						(in/out) Autre mode d'envoi de colis.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_RemiseEnMainPropre">
				<xs:annotation>
					<xs:documentation>
						(in/out) Remise en main propre.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_StandardInternational"/>
			<xs:enumeration value="FR_ExpeditedInternational"/>
			<xs:enumeration value="FR_OtherInternational"/>
			<xs:enumeration value="FR_LaPosteInternationalPriorityCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) La Poste - Courrier International Prioritaire.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_LaPosteInternationalEconomyCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) La Poste - Courrier International Economique.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_LaPosteColisPostalPriorityInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) La Poste - Colis Postal Prioritaire.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_LaPosteColisPostalEconomyInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) La Poste - Colis Postal Economique.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_EmballageColissimoInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Emballage Colissimo International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_ChronopostClassicInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Chronopost Classic International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_ChronopostPremiumInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Chronopost Premium International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_UPSStandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Standard.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_UPSExpressInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FR_DHLInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_Regular">
				<xs:annotation>
					<xs:documentation>
						(in/out) National - Regular
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_Express">
				<xs:annotation>
					<xs:documentation>
						(in/out) National - Express
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_NationalCOD">
				<xs:annotation>
					<xs:documentation>
						(in/out) National - COD
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_Courier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local - Courier
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_LocalCOD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local - COD
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) International - Standard
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) International - Expedited
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) International - other
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_FlatRateCOD">
				<xs:annotation>
					<xs:documentation>
						(in/out) Flat Rate COD
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IN_BuyerPicksUpAndPays">
				<xs:annotation>
					<xs:documentation>
						(in/out) Buyer picks up and pays
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_RegularMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Posta ordinaria.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_PriorityMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Posta prioritaria.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_MailRegisteredLetter">
				<xs:annotation>
					<xs:documentation>
						(in/out) Posta raccomandata.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_MailRegisteredLetterWithMark">
				<xs:annotation>
					<xs:documentation>
						(in/out) Posta raccomandata con contrassegno.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_InsuredMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Posta assicurata.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_QuickMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Posta celere.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_RegularPackage">
				<xs:annotation>
					<xs:documentation>
						(in/out) Pacco ordinario.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_QuickPackage1">
				<xs:annotation>
					<xs:documentation>
						(in/out) Pacco celere 1.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_QuickPackage3">
				<xs:annotation>
					<xs:documentation>
						(in/out) Pacco celere 3.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_ExpressCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Corriere espresso.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Spedizione internazionale standard a prezzo fisso.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Spedizione internazionale celere a prezzo fisso.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IT_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Altre spedizioni internazionali (vedi descrizione).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_StandardDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Standaardverzending.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_ParcelPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Pakketpost.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_RegisteredMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Verzending met ontvangstbevestiging.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_Other">
				<xs:annotation>
					<xs:documentation>
						(in/out) Andere verzendservice.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_TPGPostTNTInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) TPG Post/TNT.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_UPSInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_FedExInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Fedex.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_DHLInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) DHL.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_DPDGBRInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) DPD (Germany).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_GLSBusinessInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) GLS (Business only).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_StandardInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Vaste kosten standaard internationale verzending.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_ExpeditedInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Vaste kosten versnelde internationale verzending.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NL_OtherInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Andere internationale verzending (zie beschrijving).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TW_RegisteredMail"/>
			<xs:enumeration value="TW_UnregisteredMail"/>
			<xs:enumeration value="TW_COD"/>
			<xs:enumeration value="TW_DwellingMatchPost"/>
			<xs:enumeration value="TW_DwellingMatchCOD"/>
			<xs:enumeration value="TW_SelfPickup"/>
			<xs:enumeration value="TW_ParcelPost"/>
			<xs:enumeration value="TW_ExpressMail"/>
			<xs:enumeration value="TW_Other"/>
			<xs:enumeration value="TW_CPInternationalLetterPost"/>
			<xs:enumeration value="TW_CPInternationalParcelPost"/>
			<xs:enumeration value="TW_CPInternationalRegisteredLetterPost"/>
			<xs:enumeration value="TW_CPInternationalRegisteredParcelPost"/>
			<xs:enumeration value="TW_CPInternationalEMS"/>
			<xs:enumeration value="TW_CPInternationalOceanShippingParcel"/>
			<xs:enumeration value="TW_FedExInternationalPriority">
				<xs:annotation>
					<xs:documentation>
						(in/out) Fedex International Priority.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TW_FedExInternationalEconomy">
				<xs:annotation>
					<xs:documentation>
						(in/out) Fedex International Economy.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TW_UPSWorldwideExpedited">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Expedited.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TW_UPSWorldwideExpress">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TW_UPSWorldwideExpressPlus">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express Plus.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TW_OtherInternational"/>
			<xs:enumeration value="UK_RoyalMailFirstClassStandard">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail 1st Class Standard.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailSecondClassStandard">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail 2nd Class Standard.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailFirstClassRecorded">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail 1st Class Recorded.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailSecondClassRecorded">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail 2nd Class Recorded.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailSpecialDelivery">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail Special Delivery.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailStandardParcel">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail Standard Parcels.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_Parcelforce24">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcelforce 24.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_Parcelforce48">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcelforce 48.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_OtherCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_SellersStandardRate">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller's Standard Rate.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_CollectInPerson">
				<xs:annotation>
					<xs:documentation>
						(in/out) Collection in Person.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_SellersStandardInternationalRate">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sellers Standard International Rate.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailAirmailInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail Airmail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailAirsureInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail Airsure.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailSurfaceMailInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail Surface Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailInternationalSignedFor">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail International Signed-for.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_RoyalMailHMForcesMailInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Royal Mail HM Forces Mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_ParcelForceInternationalDatapost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcelforce International Datapost.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_ParcelForceIreland24International">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcelforce Ireland 24.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_ParcelForceEuro48International">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcelforce Euro 48.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_ParcelForceInternationalScheduled">
				<xs:annotation>
					<xs:documentation>
						(in/out) Parcelforce International Scheduled.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_OtherCourierOrDeliveryInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other courier or delivery service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK_CollectInPersonInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Collect in person.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_SellersStandardRate">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller's standard rate.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_FirstClassLetterService">
				<xs:annotation>
					<xs:documentation>
						(in/out) First Class Letter Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_SwiftPostNational">
				<xs:annotation>
					<xs:documentation>
						(in/out) SwiftPost National.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_RegisteredPost">
				<xs:annotation>
					<xs:documentation>
						(in/out) Registered Post.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_EMSSDSCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) EMS SDS Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_EconomySDSCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Economy SDS Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_OtherCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_CollectionInPerson">
				<xs:annotation>
					<xs:documentation>
						(in/out) Collection in person.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_SellersStandardRateInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller's Standard International Rate.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_InternationalEconomyService">
				<xs:annotation>
					<xs:documentation>
						(in/out) International Economy Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_InternationalPriorityService">
				<xs:annotation>
					<xs:documentation>
						(in/out) International Priority Service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_SwiftPostExpressInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) SwiftPost Express.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_SwiftPostInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) SwiftPost International.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_EMSSDSCourierInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) EMS SDS Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_EconomySDSCourierInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Economy SDS Courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_OtherCourierInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Other courier or delivery service.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="IE_CollectionInPersonInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) International collection in person.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PL_DomesticRegular">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic Regular shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PL_DomesticSpecial">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic Special shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FreightShipping">
				<xs:annotation>
					<xs:documentation>
						(in/out) Freight Shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FreightShippingInternational">
				<xs:annotation>
					<xs:documentation>
						(in/out) Freight Shipping International
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSGround">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ShippingMethodOvernight">
				<xs:annotation>
					<xs:documentation>
						(in/out) Overnight flat rate shipping service. Domestic only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSPriorityFlatRateEnvelope">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Priority.Flat Rate Envelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSPriorityFlatRateBox">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Priority.Flat Rate Box
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSGlobalPrioritySmallEnvelope">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Global Priority Mail Small Envelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSGlobalPriorityLargeEnvelope">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Global Priority Mail Large Envelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="USPSExpressFlatRateEnvelope">
				<xs:annotation>
					<xs:documentation>
						(in/out) USPS Express Mail.Flat Rate Envelope
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpressBox10kg">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express Box 10 Kg.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpressBox25kg">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express Box 25 Kg.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpressPlusBox10kg">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express Plus Box 10 Kg.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSWorldWideExpressPlusBox25kg">
				<xs:annotation>
					<xs:documentation>
						(in/out) UPS Worldwide Express Plus box 25 Kg..
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HK_LocalPickUpOnly">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local pick up only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HK_LocalCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HK_DomesticRegularShipping">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic regular shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HK_DomesticSpecialShipping">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic special shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HK_InternationalRegularShipping">
				<xs:annotation>
					<xs:documentation>
						(in/out) International regular shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HK_InternationalSpecialShipping">
				<xs:annotation>
					<xs:documentation>
						(in/out) International special shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_LocalPickUpOnly">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local pick up only.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_LocalCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) Local courier.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_DomesticStandardMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic standard mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_DomesticNonStandardMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic non standard mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_DomesticSpeedpostIslandwide">
				<xs:annotation>
					<xs:documentation>
						(in/out) Domestic Speedpost Islandwide.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_InternationalStandardMail">
				<xs:annotation>
					<xs:documentation>
						(in/out) International standard mail.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_InternationalExpressMailService">
				<xs:annotation>
					<xs:documentation>
						(in/out) International Express Mail Service (EMS).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SG_InternationalCourier">
				<xs:annotation>
					<xs:documentation>
						(in/out) International courier (DHL, FedEx, UPS).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingServiceDetailsType.xsd #####

-->
	<xs:complexType name="ShippingServiceDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details about a specific shipping service.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Full name of the shipping service for display purposes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpeditedService" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the service is an expedited shipping service.
						See Enabling Get It Fast. Whether the service is an expedited
						shipping service. Only returned for sites for which the Get It
						Fast feature is enabled and only if true.&lt;br&gt;&lt;br&gt;
						Related fields:&lt;br&gt;
						Item.DispatchTimeMax and Item.GetItFast in AddItem
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="InternationalService" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether the shipping service is an international shipping service, i.e.
						one that ships from to another country from the country of the
						specified site.&lt;br&gt;&lt;br&gt;
						Related field:&lt;br&gt;
						Item.ShippingDetails.InternationalShippingServiceOption in AddItem
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingService" type="xs:token" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Value used for the shipping service.
						For a list of valid values that you can cache for future use, call GeteBayDetails
						with DetailName set to ShippingServiceDetails.&lt;br&gt;&lt;br&gt;
						Related fields:&lt;br&gt;
						Item.ShippingDetails.InternationalShippingServiceOption.ShippingService in AddItem&lt;br&gt;
						Item.ShippingDetails.ShippingServiceOptions.ShippingService in AddItem
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Numeric identifier. A value greater than 50000 represents an
						international shipping service (confirmed by
						InternationalShippingService being true). Some applications use this ID
						to look up shipping services more efficiently.
						Also useful for applications that have migrated from the legacy XML API.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTimeMax" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The maximum guaranteed number of days the shipping carrier will
						take to ship an item (not including the time it takes the
						seller to deliver the item to the shipping carrier). Always
						returned when ExpeditedService is true or if defined for a particular service.
						See Enabling Get It Fast feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTimeMin" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The minimum guaranteed number of days the shipping carrier will
						take to ship an item (not including the time it takes the
						seller to deliver the item to the shipping carrier). Always
						returned when ExpeditedService is true or if defined for a particular service.
						See Enabling Get It Fast feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceCode" type="ShippingServiceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						For future use.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ShippingServiceOptionsType.xsd #####

-->
	<xs:complexType name="ShippingServiceOptionsType">
		<xs:annotation>
			<xs:documentation>
				Shipping costs and options related to a domestic shipping service.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ShippingInsuranceCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The insurance cost associated with shipping a single item
						with this shipping service. Exception: for GetItemShipping,
						this is proportional to QuantitySold. If the item has not yet been
						sold, insurance information cannot be calculated and the value is
						0.00. For calculated shipping only.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<SeeLink>
							<Title>Getting Shipping Cost Information</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingService" type="xs:token" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A domestic shipping service offered for shipping the item (for example, UPS
						Ground). For a list of valid values that you can cache for future use, call
						GeteBayDetails with DetailName set to ShippingServiceDetails. For flat and
						calculated shipping.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The meaning of this element depends on the call and on whether flat or
						calculated shipping has been selected. (For example, it could be the
						cost to ship a single item, the cost to ship all items, or the cost to ship
						just the first of many items, with ShippingServiceAdditionalCost accounting
						for the rest.) When returned by GetItemShipping, it includes the packaging and
						handling cost. For flat and calculated shipping.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>ScheduledList</Context>
						</CallInfo>
						<SeeLink>
							<Title>Getting Shipping Cost Information</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceAdditionalCost" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The cost of shipping each additional item beyond the first item. For input,
						this is required if the listing is for multiple items and should be zero for
						single-item listings. Default value is 0.00. For flat shipping only.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<SeeLink>
							<Title>Getting Shipping Cost Information</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=ShippingGettingCosts</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServicePriority" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Seller-preferred presentation order relative to other
						service options. Valid values: 1 (1st choice), 2 (2nd choice),
						3 (3rd choice). For flat and calculated shipping.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SendInvoice</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddOrder</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpeditedService" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the service is an expedited shipping service. See Enabling Get It Fast.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemShipping</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTimeMin" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The minimum guaranteed number of days in which the shipping carrier
						can ship an item (not including the time it takes the seller to
						deliver the item to the shipping carrier). See Enabling Get It Fast.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTimeMax" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The maximum guaranteed number of days the shipping carrier will
						take to ship an item (not including the time it takes the seller to
						deliver the item to the shipping carrier). See Enabling Get It Fast.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ShippingTermRequiredDefinitionType.xsd #####

-->
	<xs:complexType name="ShippingTermRequiredDefinitionType">
		<xs:annotation>
			<xs:documentation>
				If the field is present, the corresponding feature applies to the category. The
				field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ShippingTermsCodeList.xsd #####

-->
	<xs:simpleType name="ShippingTermsCodeType">
		<xs:annotation>
			<xs:documentation>
				Shipping terms codes indicate who pays for the shipping of
				an item, the seller or the buyer.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="SellerPays">
				<xs:annotation>
					<xs:documentation>
						(in/out) Seller pays all shipping costs.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyerPays">
				<xs:annotation>
					<xs:documentation>
						(in/out) Buyer pays all shipping costs.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ShippingTypeCodeList.xsd #####

-->
	<xs:simpleType name="ShippingTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				The shipping cost model offered by the seller.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Flat">
				<xs:annotation>
					<xs:documentation>
						(in/out) Flat shipping model: the seller establishes the cost
						of shipping and cost of shipping insurance, regardless of
						what any buyer-selected shipping service might charge the
						seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Calculated">
				<xs:annotation>
					<xs:documentation>
						(in/out) Calculated shipping model: the cost of shipping is
						determined in large part by the seller-offered and
						buyer-selected shipping service. The seller might assess an
						additional fee via PackagingHandlingCosts.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Freight">
				<xs:annotation>
					<xs:documentation>
						(out) Freight shipping model: the cost of shipping is
						determined by a third party, FreightQuote.com, based on the item
						location (zip code). Currently, Freight can only be specified
						on input via eBay Web site, not API.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Free">
				<xs:annotation>
					<xs:documentation>
						(in/out) Free shipping.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="NotSpecified">
				<xs:annotation>
					<xs:documentation>
						(in/out) The seller did not specify the shipping type.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SiteCodeList.xsd #####

-->
	<xs:simpleType name="SiteCodeType">
		<xs:annotation>
			<xs:documentation>
SiteCodeType - Type declaration to be used by other schema.
Identifies eBay sites (by the country in which each resides) on
which a user is registered and on which items can be listed.   
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="US">
				<xs:annotation>
					<xs:documentation>
						(in/out) USA, site ID 0, abbreviation US, currency USD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Canada">
				<xs:annotation>
					<xs:documentation>
						(in/out) Canada, site ID 2, abbreviation CA, currencies CAD and USD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UK">
				<xs:annotation>
					<xs:documentation>
						(in/out) United Kingdom, site ID 3, abbreviation UK, currency GBP.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Australia">
				<xs:annotation>
					<xs:documentation>
						(in/out) Australia, site ID 15, abbreviation AU, currency AUD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Austria">
				<xs:annotation>
					<xs:documentation>
						(in/out) Austria, site ID 16, abbreviation AT, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Belgium_French">
				<xs:annotation>
					<xs:documentation>
						(in/out) Belgium (French), site ID 23, abbreviation BEFR, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="France">
				<xs:annotation>
					<xs:documentation>
						(in/out) France, site ID 71, abbreviation FR, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Germany">
				<xs:annotation>
					<xs:documentation>
						(in/out) Germany, site ID 77, abbreviation DE, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Italy">
				<xs:annotation>
					<xs:documentation>
						(in/out) Italy, site ID 101, abbreviation IT, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Belgium_Dutch">
				<xs:annotation>
					<xs:documentation>
						(in/out) Belgium (Dutch), site ID 123, abbreviation BENL, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Netherlands">
				<xs:annotation>
					<xs:documentation>
						(in/out) Netherlands, site ID 146, abbreviation NL, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Spain">
				<xs:annotation>
					<xs:documentation>
						(in/out) Spain, site ID 186, abbreviation ES, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Switzerland">
				<xs:annotation>
					<xs:documentation>
						(in/out) Switzerland, site ID 193, abbreviation CH, currency CHF.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Taiwan">
				<xs:annotation>
					<xs:documentation>
						(in/out) Taiwan, site ID 196, abbreviation TW, currency TWD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayMotors">
				<xs:annotation>
					<xs:documentation>
						(in/out) eBay Motors, site ID 100, currency USD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="HongKong">
				<xs:annotation>
					<xs:documentation>
						(in/out) Hong Kong, site ID 201, abbreviation HK, currency HKD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Singapore">
				<xs:annotation>
					<xs:documentation>
						(in/out) Singapore, site ID 216, abbreviation SG, currency SGD.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="India">
				<xs:annotation>
					<xs:documentation>
						(in/out) India, site ID 203, abbreviation IN, currency INR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="China">
				<xs:annotation>
					<xs:documentation>
						(in/out) China, site ID 223, abbreviation CN, currency CNY.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Ireland">
				<xs:annotation>
					<xs:documentation>
						(in/out) Ireland, site ID 205, abbreviation IE, currency EUR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Malaysia">
				<xs:annotation>
					<xs:documentation>
						(in/out) Malaysia, site ID 207, abbreviation MY, currency MYR.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Philippines">
				<xs:annotation>
					<xs:documentation>
						(in/out) Philippines, site ID 211, abbreviation PH, currency PHP.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Poland">
				<xs:annotation>
					<xs:documentation>
						(in/out) Poland, site ID 212, abbreviation PL, currency PLN.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Sweden">
				<xs:annotation>
					<xs:documentation>
						(in/out) Sweden, site ID 218, abbreviation SE, currency SEK.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>

			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SiteDefaultsType.xsd #####

-->
	<xs:complexType name="SiteDefaultsType">
		<xs:annotation>
			<xs:documentation>
				A container node for feature definitions that apply to the entire site.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ListingDuration" type="ns:ListingDurationReferenceType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Specifies the ID of a set of default durations for a certain type of listing.
						The actual duration values are returned within the FeatureDefinitions node.
						The type of listing is named in the type attribute.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingTermsRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether sellers are
						required to specify a shipping service and its associated cost
						when listing items. True means the shipping terms are required
						unless a specific category overrides this setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether categories allow
						best offers. True means best offers are allowed site-wide,
						unless a specific category overrides the setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DutchBINEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether categories allow
						DutchBIN. True means best offers are allowed site-wide,
						unless a specific category overrides the setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserConsentRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether a bidder must consent to the bid
						by confirming that he or she read and agrees to the terms in eBay&apos;s privacy policy.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HomePageFeaturedEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether or not it is possible to enhance a listing by putting
						it into a rotation for display on a special area of the eBay home page.
						Support for this feature varies by site. Item or feedback restrictions may apply.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProPackEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether categories allow
						the ProPack feature (a feature pack). True means ProPack is allowed site-wide,
						unless a specific category overrides the setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BasicUpgradePackEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether
						categories allow the BasicUpgradePack feature (a feature pack).
						True means it is allowed site-wide, unless a specific category overrides the setting.
						Australia site (site ID 15, abbreviation AU) only. Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ValuePackEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether
						categories allow the ValuePack feature (a feature pack).
						True means it is allowed site-wide, unless a specific category overrides the setting.
						Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProPackPlusEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether
						categories allow the ProPackPlus feature (a feature pack).
						True means it is allowed site-wide, unless a specific category overrides the setting.
						Effective beginning February 22, 2006.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AdFormatEnabled" type="ns:AdFormatEnabledCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether categories allow
						the Ad Format feature. True means the feature is allowed site-wide,
						unless a specific category overrides the setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DigitalDeliveryEnabled" type="ns:DigitalDeliveryEnabledCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						eBay enables you to list and sell digital files (such as Adobe PDF files) or information that buyers
						can access online or have delivered electronically.
						This flag specifies whether most categories on the site allow digitally delivered items
						(i.e., the default setting for the site's categories).&lt;br&gt;&lt;br&gt;
						If true, digitally delivered items are allowed site-wide,
						but specific categories can override the setting if they don't support it.&lt;br&gt;
						If false, digitally delivered items are not normally allowed for the site,
						but some categories may override the setting.&lt;br&gt;&lt;br&gt;
						If a category supports digital listings, it means that you have the option to list digital items in
						that category (i.e., Item.DigitalDeliveryDetails can be specified in your listing request).
						It does not mean the category requires you to list items digitally.
						If you list in two categories, an item can only specify this option if
						both categories support digital listings.
						Digital listings are not eligible for eBay Express.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferCounterEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether categories allow
						counter offers for best offers. True means counter offers are allowed site-wide,
						unless a specific category overrides the setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferAutoDeclineEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether categories allow
						auto decline for best offers. True means auto decline is allowed site-wide,
						unless a specific category overrides the setting.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketSpecialitySubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for  whether 
						LocalMarketSpecialitySubscription feature is supported for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketRegularSubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether LocalMarketRegularSubscription 
						feature is supported for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketPremiumSubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether LocalMarketPremiumSubscription 
						feature is supported for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LocalMarketNonSubscription" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether LocalMarketNonSubscription 
						feature is supported for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether most categories on the site are eligible for eBay Express.
						eBay Express is a specialty site where customers can buy new, fixed-price goods in a more
						conventional e-commerce experience.&lt;br&gt;&lt;br&gt;
						If true, items on the site are eligible for Express,
						but specific categories can override the setting if they don't support Express.
						For example, categories that are not covered by PayPal Buyer Protection
						(e.g., Live Auctions and Motors vehicles) are excluded from Express.&lt;br&gt;
						If false, items on the site are not eligible for Express,
						but some categories may override the setting.&lt;br&gt;&lt;br&gt;
						If you list in an Express-enabled category, it does not necessarily mean that
						the item will appear in that category when buyers browse and search Express.
						It only means that the item can also be included on Express,
						assuming all other Express eligibility requirements are met.
						See "eBay Express" in the eBay Web Services guide for information about other
						eligibility requirements.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressPicturesRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether most categories on the site require a listing to include a picture
						in order to qualify for eBay Express.&lt;br&gt;&lt;br&gt;
						If true, items on the site require a picture in order to qualify for Express,
						but specific categories can override this requirement.
						For example, on the US site, pictures are normally required for Express listings. However,
						the Event Tickets category could override this requirement if pictures
						are not commonly expected for tickets.&lt;br&gt;
						If false, items on the site do not require a picture,
						but some categories may override the setting.&lt;br&gt;&lt;br&gt;
						Only meaningful if ExpressEnabled is true for the category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExpressConditionRequired" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether most categories on the site require a listing to include the Item Condition attribute
						in order to qualify for eBay Express. &lt;br&gt;&lt;br&gt;
						If true, items on the site require the Item Condition in order to qualify for Express,
						but specific categories can override this requirement.
						For example, on the US site, the Item Condition is normally required for Express listings. However,
						the Event Tickets category could override this requirement because there is little need
						to distinguish between new and used tickets. (People rarely sell used tickets
						after an event unless the ticket is also a collectible item.)&lt;br&gt;
						If false, items on the site do not require the Item Condition,
						but some categories may override the setting.&lt;br&gt;&lt;br&gt;
						Only meaningful if ExpressEnabled is true for the category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumReservePrice" type="xs:double" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether the Minimum Reserve Price 
						feature is supported for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerContactDetailsEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionConfirmationRequestEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the default site setting for whether the Transaction Confirmation 
						Request feature is supported for this category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryFeatures</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SiteDetailsType.xsd #####

-->
	<xs:complexType name="SiteDetailsType">
		<xs:annotation>
			<xs:documentation>
				Details about a specific site.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Site" type="ns:SiteCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Short name that identifies an eBay site. Usually, an eBay site is associated 
						with a particular country or region (e.g., US or Belgium_French). 
						Specialty sites (e.g., eBay Express or eBay Stores) use the same site ID as 
						their associated main eBay site. The US eBay Motors site is an exception to this convention.&lt;br&gt;&lt;br&gt;
						Related fields:&lt;br&gt;
						Item.Site in AddItem&lt;br&gt;
						User.Site in GetUser
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Numeric identifier for an eBay site. If you are using the 
						SOAP API, you use numeric site IDs in the request URL. 
						If you are using the XML API, you use numeric site IDs in the 
						X-EBAY-API-SITEID header.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SiteHostedPictureType.xsd #####

-->
	<xs:complexType name="SiteHostedPictureType">
		<xs:annotation>
			<xs:documentation>
        Data for images hosted by eBay Picture Services (EPS).With compatibility
				level 439 and higher, deprecated in the response in favor of Item.PictureDetails.
				With the future deprecation of SiteHostedPicture as input, Applications should
				use Item.PictureDetails instead.
				&lt;br&gt;&lt;br&gt;
				Note that the Gallery Plus image enhancement does not support
				SiteHostedPicture. Use Item.PictureDetails with that feature.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PictureURL" type="xs:anyURI" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(in/out) Contains the URL for an image hosted by eBay Picture
						Services (EPS) or by Picture Manager and associated with an item.
						If specified, this cannot have an empty/null value. In general, a
						listing can have a maximum of 12 picture URLs hosted by eBay Picture
						Services. For the US eBay Motors site (for all vehicle listings),
						and for the eBay Canada site for motors, the picture pack of a
						listing can contain up to 24 photos. To specify multiple pictures,
						send each URL in a separate, adjacent PictureURL element. In most
						cases, the image at the first URL is also used for the picture at
						the top of the View Item page on the Web site. For eBay Live
						Auctions, a listing can have a maximum of 5 picture URLs hosted by
						eBay Picture Services. For VerifyAddItem, you can use a fake eBay
						Picture Services URL (http://i2.ebayimg.com/abc/M28/dummy.jpg) to
						verify that your application is obtaining the correct fees for the
						quantity of images you pass in. For listing calls (e.g., AddItem):
						With the future deprecation of SiteHostedPicture as input,
						applications should use Item.PictureDetails.PictureURL instead. See
						Item.PictureDetails.PictureURL for information about how to remove
						pictures from a listing. For retrieval calls (e.g., GetItem): With
						compatibility 439 and higher, Item.PictureDetails.PictureURL is
						returned instead.
						&lt;br&gt;&lt;br&gt;
						Note that the Gallery Plus image enhancement does not support
						SiteHostedPicture. Use Item.PictureDetails with that feature.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>RelistItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PhotoDisplay" type="ns:PhotoDisplayCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the type of image display used in a listing. Some options
						are only available if images are hosted through eBay Picture
						Services (EPS), and others are not. eBay determines this by parsing
						the associated PictureURL. Cannot be used in combination with
						Listing Designer layouts. Specify None or do not add PhotoDisplay
						when ListingDesigner.LayoutID is a value other than 0.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GalleryType" type="ns:GalleryTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether a picture for the item is included in the Gallery
						and, if so whether the item is also featured in the Gallery. If the
						value is Gallery or Featured, eBay checks the available image URLs
						in the following order to determine which URL to use (if more than
						one of these URLs is available):&lt;br&gt;&lt;br&gt;
				whether the item is also featured or Plus in the Gallery.
				If the value is Gallery or Plus or Featured, eBay checks the available image URLs
            a) Use the URL in GalleryURL, if it is specified.&lt;br&gt;
            b) Otherwise, if ProductListingDetails.UseStockPhotoURLAsGallery is true, use the eBay stock photo.&lt;br&gt;
            c) Otherwise, use the value of the first PictureURL in the array of PictureURL fields, if any.&lt;br&gt;
            d) Otherwise, if ProductListingDetails.ProductID is specified, use the eBay stock photo
               (eBay resets UseStockPhotoURLAsGallery to true in this case).&lt;br&gt;
            e) If eBay is unable to find an image URL for the listing, an error is returned.&lt;br&gt;&lt;br&gt;
            See "Describing Items in a Listing" in the eBay Web Services Guide for additional information
            about working with pictures and related validation rules.
            You cannot remove Gallery or Plus or Featured when you revise a listing.
						&lt;br&gt;&lt;br&gt;
						Note that the Gallery Plus image enhancement does not support
						SiteHostedPicture. Use Item.PictureDetails with that feature.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GalleryURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						URL for a picture to be used as the Gallery thumbnail (item must be
						listed with the fee-based option to be in the Gallery or Gallery
						Featured). If the item is Gallery Featured, a value must be supplied
						for either GalleryURL or PictureURL. In either case:&lt;br&gt;
						(a) If a URL is provided only for PictureURL, it is used as the gallery thumbnail.&lt;br&gt;
						(b) If a URL is provided for both GalleryURL and PictureURL, then
						the picture indicated in GalleryURL is used as the thumbnail. The
						image used for the Gallery thumbnail must be in one of the graphics
						formats JPEG, BMP, TIF, or GIF.&lt;br&gt;
						If the item has bids (or items have been sold) or the listing ends
						within 12 hours, you can add GalleryURL or change its value, but you
						cannot remove the gallery picture if it was previously specified.
						Not applicable to eBay Motors listings. See "Describing Items in a
						Listing" in the eBay Web Services Guide for additional validation
						rules. For eBay Live Auctions, lots are listed in the gallery for
						free.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>1024</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						option to be in the Gallery or Plus or Gallery Featured). If the item is Gallery Featured, a value must
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PictureSource" type="ns:PictureSourceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					The service hosting the images in PictureURL, if any.
					This information is primarily useful for Picture Manager subscribers, who pay a
					flat subscription fee instead of individual picture fees per listing.
					Only returned when PictureURL is returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SiteIDFilterCodeList.xsd #####

-->
	<xs:simpleType name="SiteIDFilterCodeType">
		<xs:annotation>
			<xs:documentation>
				SiteIDFilterCodeType - Type declaration to be used by other schema.
				This code identifies the SiteIDFilters  to allow user to filter the
				category listings by SiteID. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ListedInCurrencyImplied">
				<xs:annotation>
					<xs:documentation>
						(in) Items listed in the currency implied by SiteID. 
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LocatedInCountryImplied">
				<xs:annotation>
					<xs:documentation> 
						(in) Items located in the country implied by SiteID.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AvailableInCountryImplied">
				<xs:annotation>
					<xs:documentation>
						(in) Items available to the country implied by SiteID. (For the US site,
						this implies listings from ALL English-language countries that are
						available to the US.)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SiteImplied">
				<xs:annotation>
					<xs:documentation>
						(in) Items listed on the site implied by SiteID, regardless of listing
						currency.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BelgiumListing">
				<xs:annotation>
					<xs:documentation>
						(in) Items located in Belgium or listed on one of the two Belgian sites.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SiteLocationType.xsd #####

-->
	<xs:complexType name="SiteLocationType">
		<xs:annotation>
			<xs:documentation>
            Contains the data that defines a site-based filter (used when
            searching for items and filtering the search result set).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SiteID" type="ns:SiteIDFilterCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A filter to use when listing categories or items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<CallName>GetCategoryListings</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SiteWideCharacteristicsType.xsd #####

-->
	<xs:complexType name="SiteWideCharacteristicsType">
		<xs:annotation>
			<xs:documentation> 
A list of one or more characteristics sets mapped to the category, if any. Use this information when working with Item Specifics (Attributes) and Pre-filled Item Information (Catalogs) functionality.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CharacteristicsSet" type="ns:CharacteristicsSetType" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						Container for site-wide characteristics set information.  
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExcludeCategoryID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
					A category that does not support the specified site-wide characteristics set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategory2CS</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SkypeContactOptionCodeList.xsd #####

-->
	<xs:simpleType name="SkypeContactOptionCodeType">
		<xs:annotation>
			<xs:documentation>
			  Indicates Skype contact options.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Chat">
				<xs:annotation>
					<xs:documentation>
						(in/out) The Skype Chat contact option.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Voice">
				<xs:annotation>
					<xs:documentation>
						(in/out) The Skype Voice contact option.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode"/>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SkypeOptionCodeList.xsd #####

-->
	<xs:simpleType name="SkypeOptionCodeType">
		<xs:annotation>
			<xs:documentation>
				Deprecated. Use values or values of SkypeContactOptionCodeType. 
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deprecated. Use values or values of SkypeContactOptionCodeType.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Voice">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deprecated. Use values or values of SkypeContactOptionCodeType.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SortOrderCodeList.xsd #####

-->
	<xs:simpleType name="SortOrderCodeType">
		<xs:annotation>
			<xs:documentation>
Indicates the order in which the catalog search engine will sort the results
if you pass a sort attribute (SortAttributeID) in search requests.
Applications cannot change the sort order of a sort attribute.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Ascending">
				<xs:annotation>
					<xs:documentation>
						The results will be sorted by the specified attribute in ascending (low to high) order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Descending">
				<xs:annotation>
					<xs:documentation>
						The results will be sorted by the specified attribute in descending (high to low) order.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SpellingSuggestionType.xsd #####

-->
	<xs:complexType name="SpellingSuggestionType">
		<xs:annotation>
			<xs:documentation>
				Suggested spelling of mispelled search terms, along with the number of matching items that would have been returned if the suggestions had been used.	
		  </xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="MatchingItemCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						The number of matching items if the suggested spelling of the search term or terms had 
						been used. If multiple terms are used, MatchingItemCount applies to the terms taken as a unit.
		      </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Text" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
					  Suggestion for a different spelling of the search term or terms. The suggestions are given in Text tags
					  and the suggestion for the first word is given before the suggestion for subsequent words.
					  Suggestions are based on correctly-spelled terms in items, so suggestions vary over time and depend on 
					  whether a word or word combination is in one or more items. 									  
  		    </xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCategoryUpdateActionCodeList.xsd #####

-->
	<xs:simpleType name="StoreCategoryUpdateActionCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies the type of action to carry out with SetStoreCategories.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Add">
				<xs:annotation>
					<xs:documentation>
						(in) Add the listed categories to the store.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delete">
				<xs:annotation>
					<xs:documentation>
						(in) Delete the listed categories from the store.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Move">
				<xs:annotation>
					<xs:documentation>
						(in) Move the listed categories from one place in the store category 
						structure to another.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Rename">
				<xs:annotation>
					<xs:documentation>
						(in) Rename the listed store categories to the names provided.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreColorSchemeArrayType.xsd #####

-->
	<xs:complexType name="StoreColorSchemeArrayType">
		<xs:annotation>
			<xs:documentation>
				Set of eBay Store color schemes.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ColorScheme" type="ns:StoreColorSchemeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A Store color scheme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreColorSchemeType.xsd #####

-->
	<xs:complexType name="StoreColorSchemeType">
		<xs:annotation>
			<xs:documentation>
				Store color scheme.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ColorSchemeID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store color scheme ID. (use GetStoreOptions to get the list of
						valid theme color scheme IDs).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store color scheme name. Provides a user-friendly name for the
						color scheme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Color" type="ns:StoreColorType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store color set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Font" type="ns:StoreFontType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store font set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreColorType.xsd #####

-->
	<xs:complexType name="StoreColorType">
		<xs:annotation>
			<xs:documentation>
				Store color set.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Primary" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Primary color for the Store. Specified in 6-digit Hex format.
						For example: F6F6C9
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>6</MaxLength>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Secondary" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Secondary color for the Store. Specified in 6-digit Hex format.
						For example: F6F6C9
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>6</MaxLength>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Accent" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Accent color for the Store. Specified in 6-digit Hex format.
						For example: F6F6C9
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>6</MaxLength>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomCategoryArrayType.xsd #####

-->
	<xs:complexType name="StoreCustomCategoryArrayType">
		<xs:annotation>
			<xs:documentation>
	  		Set of custom categories for the Store.
	  	</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CustomCategory" type="ns:StoreCustomCategoryType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
	  				A Store custom category.
	  			</xs:documentation>
  				<xs:appinfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
  					<CallInfo>
  						<CallName>SetStore</CallName>
  						<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCategories</CallName>
  						<RequiredInput>Yes</RequiredInput>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomCategoryType.xsd #####

-->
	<xs:complexType name="StoreCustomCategoryType">
		<xs:annotation>
			<xs:documentation>
				Configuration of a store custom category.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CategoryID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						Custom category ID.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>SetStoreCategories</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Name of the custom category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>SetStoreCategories</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Order" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						Order in which the custom category appears in the list of store
						categories.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>SetStoreCategories</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ChildrenCategories" type="ns:StoreCustomCategoryType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Container for store custom subcategory configuration information. This field
						is being deprecated. Use ChildCategory to specify subcategories.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ChildCategory" type="ns:StoreCustomCategoryType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Describes the configuration of a store custom subcategory. Stores support
						three levels of categories.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStoreCategories</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomHeaderLayoutCodeList.xsd #####

-->
	<xs:simpleType name="StoreCustomHeaderLayoutCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies whether the Store has a custom header.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NoHeader">
				<xs:annotation>
					<xs:documentation>
						Specifies that the Store does not have a custom header.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="CustomHeaderShown">
				<xs:annotation>
					<xs:documentation>
						Specifies that the Store does have a custom header.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomListingHeaderDisplayCodeList.xsd #####

-->
	<xs:simpleType name="StoreCustomListingHeaderDisplayCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies how the custom listing header will be displayed.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						No custom listing header is displayed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Full">
				<xs:annotation>
					<xs:documentation>
						The full custom listing header is displayed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FullAndLeftNavigationBar">
				<xs:annotation>
					<xs:documentation>
						The full custom listing header and the left navigation bar is displayed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					  (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomListingHeaderLinkCodeList.xsd #####

-->
	<xs:simpleType name="StoreCustomListingHeaderLinkCodeType">
		<xs:annotation>
			<xs:documentation>
				Specifies the type of link in the custom listing header.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="None">
				<xs:annotation>
					<xs:documentation>
						No type.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AboutMePage">
				<xs:annotation>
					<xs:documentation>
						Link is to an About Me page.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="CustomPage">
				<xs:annotation>
					<xs:documentation>
						Link is to a custom page.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="CustomCategory">
				<xs:annotation>
					<xs:documentation>
						Link is to a custom category.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomListingHeaderLinkType.xsd #####

-->
	<xs:complexType name="StoreCustomListingHeaderLinkType">
		<xs:annotation>
			<xs:documentation>
				Custom listing header link.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LinkID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
			  		Link ID for the listing header link. The ID is used when the link
			  		is a custom category or for a custom page, and it is not needed
			  		when the LinkType property is "AboutMe" or "None".
			  	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Order" type="xs:int">
				<xs:annotation>
					<xs:documentation>
			  		Order in which to show the custom listing header link.
			  	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LinkType" type="ns:StoreCustomListingHeaderLinkCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			  		Type of link to include in the custom listing header.
			  	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomListingHeaderType.xsd #####

-->
	<xs:complexType name="StoreCustomListingHeaderType">
	<xs:annotation>
		<xs:documentation>
			Configuration of a Store custom listing header.
		</xs:documentation>
	</xs:annotation>
		<xs:sequence>
			<xs:element name="DisplayType" type="ns:StoreCustomListingHeaderDisplayCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Display type for the custom listing header.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Logo" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
			  		Specifies whether the custom header has a logo.
			  	</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SearchBox" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether the custom header has a search box.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LinkToInclude" type="ns:StoreCustomListingHeaderLinkType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Link to include in the custom header.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AddToFavoriteStores" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether the custom header has a link to Add to 
						Favorite Stores.
					</xs:documentation> 
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SignUpForStoreNewsletter" type="xs:boolean" minOccurs="0">
				<xs:annotation>	
					<xs:documentation>
						Specifies whether the custom header has a link to Sign up for Store 
						Newsletter.
					</xs:documentation> 
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BreadCrumb" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether the bread crumb needs to be displayed above the listing 
						header.
					</xs:documentation> 
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomPageArrayType.xsd #####

-->
	<xs:complexType name="StoreCustomPageArrayType">
		<xs:annotation>
			<xs:documentation>
	  		Set of Store custom pages.
	  	</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CustomPage" type="ns:StoreCustomPageType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
	  				A Store custom page.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Always</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomPageStatusCodeList.xsd #####

-->
	<xs:simpleType name="StoreCustomPageStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				List of possible statuses for Store custom pages.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Active">
				<xs:annotation>
					<xs:documentation>
						(in,out) The page is visible.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Delete">
				<xs:annotation>
					<xs:documentation>
						(in) The page is to be deleted.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="Inactive">
				<xs:annotation>
					<xs:documentation>
						(in,out) The page is not visible.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreCustomPageType.xsd #####

-->
	<xs:complexType name="StoreCustomPageType">
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				Name of the Store custom page. This value is required if you are creating a 
	  				new page (by not specifying a PageID). Note that you must include a Name for 
	  				the page even if you are using the PreviewEnabled tag. However, since using 
	  				the preview functionality means that the page will not be persisted, you can 
	  				enter a dummy value for this field if you have not decided on a name for the 
	  				page. The Name is used in links to the page.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Always</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PageID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				Unique identifier for the Store custom page. When you are using 
	  				SetStoreCustomPage, if you specify a valid PageID, the custom page
	  				is updated. If you do not specify a PageID, the custom page is
	  				added.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Always</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URLPath" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				The URL path of the custom page. Only if you are using Chinese characters in 
	  				the Name property for the custom page do you need to use this field, such as 
	  				if you are opening a Store on the Taiwan site. The reason for this is that 
	  				the URL path is normally derived from the Store custom page name, but it 
	  				cannot be derived from the name of the custom page if it contains Chinese 
	  				characters because URLs cannot contain Chinese characters.
	  				URLPath is included in the GetStoreCustomPage response when PageID is 
	  				specified.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				Full URL of the Store custom page. URLPath is included in the 
	  				GetStoreCustomPage response when PageID is specified in the request.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:StoreCustomPageStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				Status of the custom page, active or inactive. Set Status to Delete with SetStoreCustomPage to delete the page.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Always</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Content" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				The HTML content of the custom page. This field has a maximum size
	  				of 96 kilobytes. If PreviewEnabled is true, then this value is required. 
	  				Otherwise, it is optional.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LeftNav" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				Specifies whether the left navigation bar is visible on the page. LeftNav 
	  				is included in the GetStoreCustomPage response when PageID is specified 
	  				in the request.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PreviewEnabled" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				If true, then the other inputs are ignored, and the content of the
	  				page as it will be displayed within the Store is returned. If
	  				false, then the page is either modified or added, and the content
	  				of the page is not returned.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>No</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Order" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
	  				Order in which the page is displayed in the list of custom pages.
	  			</xs:documentation>
  				<xs:appinfo>
  					<CallInfo>
  						<CallName>GetStoreCustomPage</CallName>
  						<Returned>Always</Returned>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<RequiredInput>Conditionally</RequiredInput>
  					</CallInfo>
  					<CallInfo>
  						<CallName>SetStoreCustomPage</CallName>
  						<Returned>Conditionally</Returned>
  					</CallInfo>
  				</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreFontFaceCodeList.xsd #####

-->
	<xs:simpleType name="StoreFontFaceCodeType">
		<xs:annotation>
			<xs:documentation>
				Font selection for Store configuration.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Arial">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Arial font.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="Courier">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Courier font.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="Times">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Times New Roman font.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="Verdana">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Verdana font.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreFontSizeCodeList.xsd #####

-->
	<xs:simpleType name="StoreFontSizeCodeType">
		<xs:annotation>
			<xs:documentation>
				Font size selection for Store configuration.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="XXS">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Extra extra small.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="XS">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Extra small.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="S">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Small.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="M">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Medium.
					</xs:documentation>
				</xs:annotation>		
			</xs:enumeration>
			<xs:enumeration value="L">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Large.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="XL">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Extra large.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="XXL">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Extra extra large.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreFontType.xsd #####

-->
	<xs:complexType name="StoreFontType">
		<xs:annotation>
			<xs:documentation>
	  		Store font set.
	  	</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="NameFace" type="ns:StoreFontFaceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font for the Store name.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NameSize" type="ns:StoreFontSizeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font size for the Store name.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NameColor" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font color for the Store name. Specified in 6-digit Hex format.
						For example: F6F6C9
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>6</MaxLength>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TitleFace" type="ns:StoreFontFaceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font for the Store section title.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TitleSize" type="ns:StoreFontSizeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font size for the Store section title.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TitleColor" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font color for the Store section title. Specified in 6-digit Hex
						format. For example: F6F6C9
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DescFace" type="ns:StoreFontFaceCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font for the Store description.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DescSize" type="ns:StoreFontSizeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font size for the Store description.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DescColor" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Font color for the Store description. Specified in 6-digit Hex
						format. For example: F6F6C9
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreHeaderStyleCodeList.xsd #####

-->
	<xs:simpleType name="StoreHeaderStyleCodeType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Full">
				<xs:annotation>
					<xs:documentation>
						The full Store header is used.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Minimized">
				<xs:annotation>
					<xs:documentation>
						A minimized Store header is used.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreItemListLayoutCodeList.xsd #####

-->
	<xs:simpleType name="StoreItemListLayoutCodeType">
		<xs:annotation>
			<xs:documentation>
				Set of available layouts for items listed in an eBay Store.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ListView">
				<xs:annotation>
					<xs:documentation>
						Displays item list as a single column, with smaller item pictures.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="GalleryView">
				<xs:annotation>
					<xs:documentation>
						Displays item list in two columns, with larger item pictures.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreItemListSortOrderCodeList.xsd #####

-->
	<xs:simpleType name="StoreItemListSortOrderCodeType">
		<xs:annotation>
			<xs:documentation>
				List of available options for how items are sorted in an eBay Store.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="EndingFirst">
				<xs:annotation>
					<xs:documentation>
						(in,out) Lists items with those ending soon listed first.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="NewlyListed">
				<xs:annotation>
					<xs:documentation>
						(in,out) Lists items with those newly listed appearing in the list first.
					</xs:documentation>
				</xs:annotation>					
			</xs:enumeration>
			<xs:enumeration value="LowestPriced">
				<xs:annotation>
					<xs:documentation>
						(in,out) Lists items by price in ascending order. The item with the lowest
						starting price is listed first.
					</xs:documentation>
				</xs:annotation>					
			</xs:enumeration>
			<xs:enumeration value="HighestPriced">
				<xs:annotation>
					<xs:documentation>
						(in,out) Lists items by price in descending order. The item with the highest
						starting price is listed first.
					</xs:documentation>
				</xs:annotation>				
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreLogoArrayType.xsd #####

-->
	<xs:complexType name="StoreLogoArrayType">
		<xs:annotation>
			<xs:documentation>
				Set of Store logos.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Logo" type="ns:StoreLogoType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A Store logo.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreLogoType.xsd #####

-->
	<xs:complexType name="StoreLogoType">
		<xs:annotation>
			<xs:documentation>
				Store logo.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="LogoID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store logo ID (use GetStoreOptions to get the list of valid logo IDs).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store logo name. Provides a user-friendly name for the logo.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						URL of the logo. Must have a .gif or .jpg extention. Specified when
						you are using a customized logo.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StorePreferencesType.xsd #####

-->
	<xs:complexType name="StorePreferencesType">
		<xs:annotation>
			<xs:documentation>
				Store Preferences type.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="VacationPreferences" type="ns:StoreVacationPreferencesType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store vacation hold preferences.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreSearchCodeList.xsd #####

-->
	<xs:simpleType name="StoreSearchCodeType">
		<xs:annotation>
			<xs:documentation>
Identifies the StoreSearch codes (e.g., for GetSearchResults requests).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="AllItemsInTheStore">
				<xs:annotation>
					<xs:documentation>
                (in) Within a single store for all items (specify store in
                SearchStoreFilterType.StoreName).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AuctionItemsInTheStore">
				<xs:annotation>
					<xs:documentation> 
                (in) Within a single store for auction items (specify store in
                SearchStoreFilterType.StoreName).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyItNowItemsInTheStore">
				<xs:annotation>
					<xs:documentation> 
                (in) Within a single store for basic fixed price items, Store Inventory format items, 
                and auction items with Buy It Now. (Specify store in SearchStoreFilterType.StoreName).
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="BuyItNowItemsInAllStores">
				<xs:annotation>
					<xs:documentation> 
                (in) Across all stores for basic fixed price items, Store Inventory format items, 
                and auction items with Buy It Now.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreSubscriptionArrayType.xsd #####

-->
	<xs:complexType name="StoreSubscriptionArrayType">
		<xs:annotation>
			<xs:documentation>
				Set of eBay Store subscription levels.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Subscription" type="ns:StoreSubscriptionType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A Store subscription level.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreSubscriptionLevelCodeList.xsd #####

-->
	<xs:simpleType name="StoreSubscriptionLevelCodeType">
		<xs:annotation>
			<xs:documentation>
				User's eBay Store subscription level.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Close">
				<xs:annotation>
					<xs:documentation>
					   (in) Used to cancel the user's eBay Store subscription.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="Basic">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Basic level subscription.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="Featured">
				<xs:annotation>
					<xs:documentation>
					   (in,out) Featured level subscription.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="Anchor">
				<xs:annotation>
					<xs:documentation>
					   (out) Anchor level subscription.
					</xs:documentation>
				</xs:annotation>			
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
					   (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/StoreSubscriptionType.xsd #####

-->
	<xs:complexType name="StoreSubscriptionType">
		<xs:sequence>
			<xs:element name="Level" type="ns:StoreSubscriptionLevelCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store subscription level.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Fee" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Monthly fee for the Store subscription level.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreThemeArrayType.xsd #####

-->
	<xs:complexType name="StoreThemeArrayType">
		<xs:annotation>
			<xs:documentation>
				Set of Store themes.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Theme" type="ns:StoreThemeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A Store theme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GenericColorSchemeArray" type="ns:StoreColorSchemeArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Set of color schemes. This set is for use with those themes that do
						not explicitly list a color scheme in the theme definition (these
						themes are also known as advanced themes).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
							<Context>AdvancedThemeArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreThemeType.xsd #####

-->
	<xs:complexType name="StoreThemeType">
		<xs:annotation>
			<xs:documentation>
				Store theme.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ThemeID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store theme ID (use GetStoreOptions to get the list of valid theme
						IDs).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store theme name. Provides a user-friendly name for the theme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ColorScheme" type="ns:StoreColorSchemeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Theme color scheme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetStoreOptions</CallName>
							<Returned>Always</Returned>
							<Context>BasicThemeArray</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreType.xsd #####

-->
	<xs:complexType name="StoreType">
		<xs:annotation>
			<xs:documentation>
	      The configuration of an eBay Store.
	    </xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Name of the eBay Store. The name is shown
						at the top of the Store page.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>35</MaxLength>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URLPath" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The URL path of the Store (58 characters maximum). Only if you
						are using Chinese characters in the Name property do you need to
						use this field, such as if you are opening a Store on the Taiwan
						site. The reason for this is that the URL path is normally derived
						from the Store name, but it cannot be derived from the name of the
						Store if it contains Chinese characters because URLs cannot
						contain Chinese characters.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The complete URL of the user's Store. This field is only ever
						returned, and does not need to be explicitly set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SubscriptionLevel" type="ns:StoreSubscriptionLevelCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Subscription level (tier) for the user's eBay Store.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store description (300 characters maximum).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Logo" type="ns:StoreLogoType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store logo.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Theme" type="ns:StoreThemeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Store theme.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HeaderStyle" type="ns:StoreHeaderStyleCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Style for the Store header.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HomePage" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Page to use as the Store's homepage (default is 0). To change the
						homepage, specify the PageID of one of the Store's custom pages.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemListLayout" type="ns:StoreItemListLayoutCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The default layout type to use for the Store items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ItemListSortOrder" type="ns:StoreItemListSortOrderCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The default sort order to use for the items for sale in the Store.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CustomHeaderLayout" type="ns:StoreCustomHeaderLayoutCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Layout for the Store's custom header.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CustomHeader" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Custom header text for the Store.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExportListings" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether to export the Store listings to comparison
						shopping websites.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CustomCategories" type="ns:StoreCustomCategoryArrayType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Custom categories for the Store. Deprecated (input ignored) for SetStore with
						compatibility level 449 or higher. Use SetStoreCategories with compatibility
						level 449 or higher to modify store category structures.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CustomListingHeader" type="ns:StoreCustomListingHeaderType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Custom listing header for the Store.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MerchDisplay" type="ns:MerchDisplayCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the chosen customization display scheme for this store's Merch Widgets.
						See MerchDisplayCodeType for specific values.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastOpenedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Indicates the time the store was last opened or reopened.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetStore</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetStore</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StoreVacationPreferencesType.xsd #####

-->
	<xs:complexType name="StoreVacationPreferencesType">
		<xs:annotation>
			<xs:documentation>
				Specifies a set of Store vacation preferences.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="OnVacation" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies whether the Store owner is on vacation.&lt;br&gt;
						When OnVacation is true, the Store owner's listings do not appear on Express,
						regardless of the listing format and regardless of how the seller has configured
						their vacation settings for items that appear on eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ReturnDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Seller return date from vacation.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="HideFixedPriceStoreItems" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Hide Store Inventory format items when the Store owner is on vacation.&lt;br&gt;&lt;br&gt;
						When OnVacation is true, the Store owner's listings do not appear on Express,
						regardless of the listing format and regardless of how the seller has configured
						their vacation settings for items that appear on eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageItem" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Add a message when the Store owner is on vacation to all their active items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageStore" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Add a message to all the Store pages when the Store owner is on vacation.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DisplayMessageStoreCustomText" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Display custom message on the Store pages instead of the default message.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10000</MaxLength>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MessageStoreCustomText" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The custom message to display for the Store when the user is on vacation.
						May contain HTML markup.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetStorePreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>SetStorePreferences</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StorefrontType.xsd #####

-->
	<xs:complexType name="StorefrontType">
		<xs:annotation>
			<xs:documentation> 
				Contains information related to the item in the context of 
				a seller's eBay Store. Applicable for auction format, Basic Fixed Price, 
				and Store Inventory format items listed by eBay Stores sellers. 
 			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="StoreCategoryID" type="xs:int">
				<xs:annotation>
					<xs:documentation> 
						Numeric ID for a custom category that the seller created in their eBay Store, 
						if any. eBay Stores sellers can create up to three levels of custom 
						categories for their stores. Items can only be listed in store categories 
						that have no child categories (subcategories). If you attempt to list an item 
						in a category that has subcategories, the call response contains a warning, 
						and the item is listed in the Other store category.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>							
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StoreCategory2ID" type="xs:int">
				<xs:annotation>
					<xs:documentation>
						Applicable for eBay Store sellers only. Numeric ID for a second custom 
						category that the seller created in their eBay Store. eBay Stores sellers can 
						create up to 300 custom categories for their stores. (One additional Store 
						category cannot be customized and retains the value of "Other"). &lt;br&gt;
						If you specify an invalid value, the values are the same for both the primary 
						and secondary store categories, or if the seondary store category is 
						specified but the primary is left blank (or other),  the system resets the 
						value to 0 (None). In short, the primary store category must be set to 
						something meaningful and different from the second store category
						in order to set the secondary store category to a value other than 0.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>							
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StoreURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						The URL of the seller's eBay Store page. 
						Output only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>							
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
            <xs:element name="StoreName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
					The name of the seller's eBay Store.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>		
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/StringMatchCodeType.xsd #####

-->
	<xs:simpleType name="StringMatchCodeType">
		<xs:annotation>
			<xs:documentation>
				(in) Indicates the type of string matching to use
				when a value is submitted in CharityName. If no value is
				specified, default behavior is "StartsWith." Does not
				apply to Query.
			</xs:documentation>
		</xs:annotation>
			<xs:restriction base="xs:token">
				<xs:enumeration value="CustomCode">
					<xs:annotation>
						<xs:documentation>
							(in) Reserved for internal or future use.
						</xs:documentation>
					</xs:annotation>
				</xs:enumeration>
				<xs:enumeration value="StartsWith">
					<xs:annotation>
						<xs:documentation>
							(in) Matches strings that begin with the submitted
							value. For example, submitting a CharityName value
							of "heart" matches "Heart of Gold," but not "Open
							Hearts." Default behavior if no value is
							specified.
						</xs:documentation>
					</xs:annotation>
				</xs:enumeration>
				<xs:enumeration value="Contains">
					<xs:annotation>
						<xs:documentation>
							(in) Matches strings that contain the submitted
							value. For example, submitting a CharityName value
							of "heart" matches both "Heart of Gold" and "Open
							Hearts."
						</xs:documentation>
					</xs:annotation>
				</xs:enumeration>
			</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SubscriptionType.xsd #####

-->
	<xs:complexType name="SubscriptionType">
		<xs:annotation>
			<xs:documentation> 
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EIASToken" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteID" type="ns:SiteCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="Active" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SuggestedCategoryArrayType.xsd #####

-->
	<xs:complexType name="SuggestedCategoryArrayType">
		<xs:annotation>
			<xs:documentation>
	     Contains an array of categories that contain listings with
	     specified keywords in their titles or descriptions. The array
	     can contain up to 10 categories.
        </xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="SuggestedCategory" type="ns:SuggestedCategoryType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
	    			Describes a category that contains listings that match
	    			specified keywords in the query. Returned if a category matches the query.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SuggestedCategoryType.xsd #####

-->
	<xs:complexType name="SuggestedCategoryType">
		<xs:annotation>
			<xs:documentation>
	      Defines a suggested category, returned
	      in response to a search for categories that contain
	      listings with certain keywords in their titles and descriptions.
	    </xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Category" type="ns:CategoryType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Describes a category that contains items that match the query.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PercentItemFound" type="xs:int">
				<xs:annotation>
					<xs:documentation>
					Percentage of the matching items that were found in this category, 
					relative to other categories in which matching items were also found. 
					Indicates the distribution of matching items across the suggested categories. 
				</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSuggestedCategories</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SummaryEventScheduleType.xsd #####

-->
	<xs:complexType name="SummaryEventScheduleType">
		<xs:annotation>
			<xs:documentation>
				Details about a summary event schedule.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EventType" type="ns:NotificationEventTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The event type associated with this alert.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SummaryPeriod" type="ns:SummaryWindowPeriodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The period of time for which to create a summary.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Frequency" type="ns:SummaryFrequencyCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						How often the summary is to be delivered.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetNotificationPreferences</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetNotificationPreferences</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/SummaryFrequencyCodeList.xsd #####

-->
	<xs:simpleType name="SummaryFrequencyCodeType">
		<xs:annotation>
			<xs:documentation>
				How often the summary is to be delivered.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="EverySunday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Sunday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EveryMonday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Monday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EveryTuesday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Tuesday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EveryWednesday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Wednesday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EveryThursday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Thursday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EveryFriday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Friday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="EverySaturday">
				<xs:annotation>
					<xs:documentation>
						Deliver every Saturday.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn1st">
				<xs:annotation>
					<xs:documentation>
						On day 1 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn2nd">
				<xs:annotation>
					<xs:documentation>
						On day 2 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn3rd">
				<xs:annotation>
					<xs:documentation>
						On day 3 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn4th">
				<xs:annotation>
					<xs:documentation>
						On day 4 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn5th">
				<xs:annotation>
					<xs:documentation>
						On day 5 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn6th">
				<xs:annotation>
					<xs:documentation>
						On day 6 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn7th">
				<xs:annotation>
					<xs:documentation>
						On day 7 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn8th">
				<xs:annotation>
					<xs:documentation>
						On day 8 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn9th">
				<xs:annotation>
					<xs:documentation>
						On day 9 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn10th">
				<xs:annotation>
					<xs:documentation>
						On day 10 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn11th">
				<xs:annotation>
					<xs:documentation>
						On day 11 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn12th">
				<xs:annotation>
					<xs:documentation>
						On day 12 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn13th">
				<xs:annotation>
					<xs:documentation>
						On day 13 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn14th">
				<xs:annotation>
					<xs:documentation>
						On day 14 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn15th">
				<xs:annotation>
					<xs:documentation>
						On day 15 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn16th">
				<xs:annotation>
					<xs:documentation>
						On day 16 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn17th">
				<xs:annotation>
					<xs:documentation>
						On day 17 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn18th">
				<xs:annotation>
					<xs:documentation>
						On day 18 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn19th">
				<xs:annotation>
					<xs:documentation>
						On day 19 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn20th">
				<xs:annotation>
					<xs:documentation>
						On day 20 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn21st">
				<xs:annotation>
					<xs:documentation>
						On day 21 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn22nd">
				<xs:annotation>
					<xs:documentation>
						On day 22 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn23rd">
				<xs:annotation>
					<xs:documentation>
						On day 23 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn24th">
				<xs:annotation>
					<xs:documentation>
						On day 24 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn25th">
				<xs:annotation>
					<xs:documentation>
						On day 25 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn26th">
				<xs:annotation>
					<xs:documentation>
						On day 26 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn27th">
				<xs:annotation>
					<xs:documentation>
						On day 27 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn28th">
				<xs:annotation>
					<xs:documentation>
						On day 28 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn29th">
				<xs:annotation>
					<xs:documentation>
						On day 29 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn30th">
				<xs:annotation>
					<xs:documentation>
						On day 30 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MonthlyOn31st">
				<xs:annotation>
					<xs:documentation>
						On day 31 of the month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Every31Days">
				<xs:annotation>
					<xs:documentation>
						Every 31 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Every60Days">
				<xs:annotation>
					<xs:documentation>
						Every 60 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SummaryWindowPeriodCodeList.xsd #####

-->
	<xs:simpleType name="SummaryWindowPeriodCodeType">
		<xs:annotation>
			<xs:documentation>
				The period of time for which to create a summary.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Last24Hours">
				<xs:annotation>
					<xs:documentation>
						(in/out) The last 24 hours.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Last7Days">
				<xs:annotation>
					<xs:documentation>
						(in/out) The last 7 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Last31Days">
				<xs:annotation>
					<xs:documentation>
						(in/out) The last 31 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CurrentWeek">
				<xs:annotation>
					<xs:documentation>
						(in/out) The current week.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LastWeek">
				<xs:annotation>
					<xs:documentation>
						(in/out) The prior week.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CurrentMonth">
				<xs:annotation>
					<xs:documentation>
						(in/out) The current month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LastMonth">
				<xs:annotation>
					<xs:documentation>
						(in/out) The prior month.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Last60Days">
				<xs:annotation>
					<xs:documentation>
						(in/out) The last 60 days.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/SupportedEventTypesArrayType.xsd #####

-->
	<xs:complexType name="SupportedEventTypesArrayType">
		<xs:annotation>
			<xs:documentation>
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="EventType" type="ns:NotificationEventTypeCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/TCREnabledDefinitionType.xsd #####

-->
	<xs:complexType name="TCREnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the Transaction Confirmation Request feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/TaskStatusCodeList.xsd #####

-->
	<xs:simpleType name="TaskStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				Status values for the processing progress for the category structure changes 
				specified by a SetStoreCategories request. If the SetStoreCategories call is 
				processed asynchronously, then the status is returned by 
				GetStoreCategoryUpdateStatus, otherwise, the status is returned in the 
				SetStoreCategories response.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Pending">
				<xs:annotation>
					<xs:documentation>
						(out) The category changes have not started.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InProgress">
				<xs:annotation>
					<xs:documentation>
						(out) The category changes are in progress.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Complete">
				<xs:annotation>
					<xs:documentation>
						(out) The category changes completed successfully.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Failed">
				<xs:annotation>
					<xs:documentation>
						(out) The category changes failed.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/TaxJurisdictionType.xsd #####

-->
	<xs:complexType name="TaxJurisdictionType">
		<xs:annotation>
			<xs:documentation>
				Tax-related details for a region or jurisdiction.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="JurisdictionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Representative identifier for the jurisdiction. Typically an
						abbreviation (e.g. CA for California).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GeteBayDetails</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetTaxTable</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>SetTaxTable</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SalesTaxPercent" type="xs:float" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The tax percent to apply for a listing shipped to this
						jurisdiction. The value passed in is stored with a precision of
						3 digits after the decimal point (##.###).
						GetTaxTable: this tag has no value if the user's tax table has not been set.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetTaxTable</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetTaxTable</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingIncludedInTax" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether shipping costs are to be part of the base amount that is taxed.
						GetTaxTable: This tag is empty if the user did not previously provide information.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetTaxTable</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>SetTaxTable</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="JurisdictionName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Full name for the jurisdiction or region for display purposes.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/TaxTableType.xsd #####

-->
	<xs:complexType name="TaxTableType">
		<xs:annotation>
			<xs:documentation>
				Sales tax details for zero or more jurisdictions (states,
				provinces, etc).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TaxJurisdiction" type="ns:TaxJurisdictionType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Sales tax details for zero or more jurisdictions (states,
						provinces, etc).
						For GetTaxTable, if DetailLevel is not specified, information is only
						returned for the jurisdictions for which the user provided tax
						information. If DetailLevel is ReturnAll, tax information
						is returned for all possible jurisdictions, whether
						specified by the user or not. ShippingIncludedInTax and
						SalesTaxPercent are returned but are empty.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>SetTaxTable</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetTaxTable</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll, none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItemShipping</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ThemeGroupType.xsd #####

-->
	<xs:complexType name="ThemeGroupType">
		<xs:annotation>
			<xs:documentation>
				Data for one theme group. Returned for GetDescriptionTemplates
				if theme groups are requested.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="GroupID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for this theme group.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GroupName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Name of this theme group (localized to the language associated 
						with the eBay site).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ThemeID" type="xs:int" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for each theme in this group. There
						is at least one theme in a theme group.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ThemeTotal" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The number of ThemeID elements in this group.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetDescriptionTemplates</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/TokenReturnMethodCodeList.xsd #####

-->
	<xs:simpleType name="TokenReturnMethodCodeType">
		<xs:annotation>
			<xs:documentation>
Used to specify how the application wants eBay to handle the user's token after the 
user signs in. There are two options: redirect with token, or leave the token at 
eBay and fetch the token through an API call to FetchToken.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Redirect">
				<xs:annotation>
					<xs:documentation>
						     (out) Return the token in the HTTP redirect to the application-specified
						     accept URL
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="FetchToken">
				<xs:annotation>
					<xs:documentation>
						    (out) Leaves the token at eBay so that the application can get 
						    the token through the FetchToken API call (SecretId required)
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/TradingRoleCodeList.xsd #####

-->
	<xs:simpleType name="TradingRoleCodeType">
		<xs:annotation>
			<xs:documentation>
              Specifies a person's role in doing business on eBay.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Buyer">
				<xs:annotation>
					<xs:documentation>
                      (out) The buyer.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Seller">
				<xs:annotation>
					<xs:documentation>
                     (out) The seller.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
                      (out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/TransactionArrayType.xsd #####

-->
	<xs:complexType name="TransactionArrayType">
		<xs:annotation>
			<xs:documentation>
				(out) Contains an array of transactions.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Transaction" type="ns:TransactionType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Information about one transaction.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/TransactionPlatformType.xsd #####

-->
	<xs:simpleType name="TransactionPlatformType">
		<xs:annotation>
			<xs:documentation>
			Specifies the site on which the purchase was made.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="eBay">
				<xs:annotation>
					<xs:documentation>
					The transaction was created (i.e., the purchase was made) 
					on the main eBay site.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Express">
				<xs:annotation>
					<xs:documentation>
					The transaction was created on the eBay Express site.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/TransactionStatusType.xsd #####

-->
	<xs:complexType name="TransactionStatusType">
		<xs:annotation>
			<xs:documentation>
				Contains the status of the transaction, such as the buyer's online
				payment and whether the checkout process for the transaction has
				been completed.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="eBayPaymentStatus" type="ns:PaymentStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the success or failure of the buyer's online payment
						for a transaction. Only applicable if the buyer chose PayPal as
						the payment method for the transaction. If the payment failed,
						the value returned indicates the reason for the failure. Output
						only.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CheckoutStatus" type="ns:CheckoutStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the current status of the checkout process for the transaction.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="LastTimeModified" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates date and time a transaction's status or incomplete
						state was last updated (in GMT).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaymentMethodUsed" type="ns:BuyerPaymentMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Payment method the buyer selected for paying the seller
						for the transaction. If checkout is not yet complete,
						PaymentMethodUsed is set to whatever the buyer selected as his
						or her preference on the Review Your Purchase page.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CompleteStatus" type="ns:CompleteStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the transaction process is complete or incomplete.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerSelectedShipping" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the buyer has selected shipping details
						during checkout. False indicates that the shipping service was
						selected by eBay for the buyer. For example, if the buyer has
						not yet completed the Review Your Purchase page, he has not
						picked a shipping service. If it is false, the application
						should ignore ShippingServiceCost and ShippingServiceSelected
						(items whose values are defaulted by eBay).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<DetailLevels>none</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/TransactionType.xsd #####

-->
	<xs:complexType name="TransactionType">
		<xs:annotation>
			<xs:documentation>
				Contains information about a single transaction. A transaction contains information
				about the sale one or multiple items from a listing to a single buyer. The eBay
				system creates a transaction when a buyer has made a purchase (fixed-price listings)
				or is the winning bidder (BIN and competitive-bidding listings). A listing can spawn
				one or more transactions in these cases: multi-item fixed-price listings and Dutch
				listings. A listing can spawn only a single transaction in these cases: single-item
				fixed-price listings and Chinese listings.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AmountPaid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The amount the buyer paid for the item(s) in the transaction.
						If the seller allowed the buyer to change the item total, the buyer
						is able to change the total until the time that the transaction's
						status moves to Complete. Determine whether the buyer
						changed the amount by retrieving the transaction data and comparing
						the AmountPaid value to what the seller expected. For Motors items,
						AmountPaid is the amount paid by the buyer for the deposit.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="AdjustmentAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Adjustment amount entered by the buyer. A positive amount indicates the amount
						is an extra charge being paid to the seller by the buyer. A negative value
						indicates this amount is a credit given to the buyer by the seller. Not
						applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedAdjustmentAmount" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Converted value of AdjustmentAmount in the currency of the site that returned
						the response. Refresh this value every 24 hours to pick up the current
						conversion rates. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Buyer" type="ns:UserType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains the data for the transaction&apos;s buyer. See UserType for its
						child elements.
						Not applicable to Half.com except for GetOrders.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetOrders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingDetails" type="ns:ShippingDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The shipping-related details for an item or transaction, including flat and
						calculated shipping costs and shipping insurance costs. For GetOrders, also
						applicable to Half.com. For GetOrders, minimal ShippingDetails information is
						returned under the Transaction container.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<SeeLink>
							<Title>Shipping</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=Shipping</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedAmountPaid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
						<xs:documentation>
							Converted value of AmountPaid in the currency of the site that returned the
							response. Refresh this value every 24 hours to pick up the current
							conversion rates.
							Not applicable to Half.com.
					 	</xs:documentation>
						<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ConvertedTransactionPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Converted value of TransactionPrice in the currency of the site that returned the
						response. Refresh this value every 24 hours to pick up the current conversion rates.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CreatedDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates when the transaction was created. For fixed-price, Stores, and BIN items
						this indicates when the purchase (or BIN) occurred. For competitive-bidding listing
						types this indicates when listing ended, the winning bidder(s) determined, and the
						transaction created.
						For GetOrders, only applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="DepositType" type="ns:DepositTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Deposit type for US eBay Motors items. If item is not a Motors item, then
						returns an empty value for DepositType. See DepositTypeCodeType for specific
						values.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Item" type="ns:ItemType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Information about the item that spawned the transaction. It is a purchase from
						this item&apos;s listing that the transaction represents. To remove a property
						from an item, specify it in ModifyType as a changed property, but do not give
						it a value in Item.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="QuantityPurchased" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the number of items the buyer purchased from the listing identified
						in ItemID.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:TransactionStatusType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains the status of the transaction, such as the buyer&apos;s online payment and
						whether the checkout process for the transaction has been completed. See
						TransactionStatusType for its child elements.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Identifier for the transaction.
						A value of zero is used for the Chinese auction format.
						Thus, a value of zero is a valid transaction ID.
						A transaction ID is only unique to the listing
						that spawned it, so a transaction is only uniquely identified on a global basis by
						a combination of ItemID and TransactionID.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>AddOrder</CallName>
							<RequiredInput>Yes</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Price of the transaction (before shipping and sales tax) that the buyer needs to pay
						to complete the purchase. For eBay Motors, TransactionPrice is the deposit amount.
						Also applicable to Half.com (for GetOrders).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BestOfferSale" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Whether the transaction was completed with the seller selecting
						a best offer.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VATPercent" type="xs:decimal" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						VAT rate for the item. When the VATPercent is specified, the item&apos;s VAT
						information appears on the item&apos;s listing page. In addition, the seller
						can choose to print an invoice that includes the item&apos;s net price, VAT
						percent, VAT amount, and total price. Since VAT rates vary depending on the
						item and on the user&apos;s country of residence, a seller is responsible for
						entering the correct VAT rate; it is not calculated by eBay. To specify a
						VATPercent, a seller must have a VAT-ID registered with eBay and must be
						listing the item on a VAT-enabled site. Max precision 3 decimal places. Max
						length 5 characters. Note: The View Item page displays the precision to 2
						decimal places with no trailing zeros. However, the full value you send in is
						stored. Not applicable to Half.com.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ExternalTransaction" type="ns:ExternalTransactionType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						A PayPal transaction that relates to this eBay transaction.
						Returned only if there is at least one PayPal transaction related to this
						eBay transaction.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellingManagerProductDetails" type="ns:SellingManagerProductDetailsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippingServiceSelected" type="ns:ShippingServiceOptionsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The shipping service selected by the buyer from the services
						offered by the seller.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<SeeLink>
							<Title>Shipping</Title>
							<URL>http://developer.ebay.com/DevZone/XML/docs/WebHelp/index.htm?context=eBay_XML_API&amp;topic=Shipping</URL>
						</SeeLink>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerMessage" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Display message from buyer. This field holds transient
						data that is only being returned in the notification flow.
						This field is only returned in the Checkout related notifications.
						Not applicable to Half.com.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="DutchAuctionBid" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						This field holds the Dutch Auction Offer Bid by the buyer in this transaction,
						if this is a Dutch Auction Item. This field will only be returned if caller has set
						IncludeDuctionAuctionBid to true.
						Not applicable to Half.com.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerPaidStatus" type="ns:PaidStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the transaction's paid status, as seen by the buyer.
						Returned in lists of won and sold items.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerPaidStatus" type="ns:PaidStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Specifies the transaction's payment status, as seen by the seller.
						Returned in lists of won and sold items.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PaidTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the time when the transaction was marked paid, if known.
						The value is set by eBay when payment is made via PayPal or a
						third-party checkout flow.
						This value is also set when the seller marks the item as
						paid by using ReviseCheckoutStatus or CompleteSale.
						The seller can also mark the item as paid by using My eBay
						or Selling Manager Pro.
						Note that this value is only visible if the request user is
						the buyer or seller associated with the transaction.
						If the item is marked as paid but the seller is not a
						Selling Manager Pro user, PaidTime returns the
						transaction creation time instead.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ShippedTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the time when the item(s) associated with the transaction were
						marked as shipped, if known. The value is set when the seller uses shipment
						tracking features offered by eBay or an eBay partner. This value is also set
						when the seller marks the item as shipped by using CompleteSale. If the seller
						is a Selling Manager Pro user, they can also mark the item as shipped by using
						My eBay. Note that this value is only visible if the request user is the buyer
						or seller associated with the transaction. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TotalPrice" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not applicable to Half.com.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackLeft" type="ns:FeedbackInfoType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackReceived" type="ns:FeedbackInfoType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ContainingOrder" type="ns:OrderType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The order to which the transaction belongs.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="FinalValueFee" type="ns:AmountType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						You are charged a Final Value Fee if your item is sold, ends with a winning
						bid, or is purchased. This fee applies whether or not you actually complete
						the sale with the buyer. If you request a Final Value Fee Credit, the value of
						Transaction.FinalValueFee will not change for the item if a credit is issued.
						(The credit only appears in the seller's account data.) See the eBay.com Web
						site online help for more information about the Final Value Fee. The Final
						Value Fee for FixedPriceItem, StoresFixedPrice, and Buy It Now Dutch listing
						types is returned by GetSellerTransactions and GetItemTransactions on a
						transaction by transaction basis. For all other listing types, including
						Chinese and Dutch (no Buy It Now purchases), the Final Value Fee is returned
						when the listing status is Completed. If the item was a Dutch auction that
						ended with bids (not Buy It Now purchases), the Final Value Fee is returned in
						Item.SellingStatus.FinalValueFee. For all other listing types, including Dutch
						auctions that end with Buy It Now purchases, the Final Value Fee is returned
						in Transaction.FinalValueFee. Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TransactionPlatform" type="ns:TransactionPlatformType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the platform the item was purchased on (such as eBay or eBay Express).
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ProStoresStoreName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of the store, if Item.ThirdPartyCheckout is true.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/UPSRateOptionCodeList.xsd #####

-->
	<xs:simpleType name="UPSRateOptionCodeType">
		<xs:annotation>
			<xs:documentation>
				UPS Rate Options
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="UPSDailyRates">
				<xs:annotation>
					<xs:documentation>
						UPS Daily Rates
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UPSOnDemandRates">
				<xs:annotation>
					<xs:documentation>
						UPS On-Demand Rates
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						 Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/URLDetailsType.xsd #####

-->
	<xs:complexType name="URLDetailsType">
		<xs:annotation>
			<xs:documentation> 
				Details about a specific eBay URL.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="URLType" type="ns:URLTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						A compressed, representative title for the eBay URL.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="URL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						A commonly used eBay URL. Applications use some of these URLs (such as the View Item URL)
						to launch eBay Web site pages in a browser.&lt;br&gt;&lt;br&gt;
						Logo URLs are required to be used in certain types of applications.
						See your API license agreement. Also see this page for logo usage rules:&lt;br&gt;
						http://developer.ebay.com/join/licenses/apilogousage
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GeteBayDetails</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/URLTypeCodeList.xsd #####

-->
	<xs:simpleType name="URLTypeCodeType">
		<xs:annotation>
			<xs:documentation>
				A compressed, representative title for the eBay URL.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="ViewItemURL">
				<xs:annotation>
					<xs:documentation>
						URL Prefix for viewing a particular listing. Just add an item id.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ViewUserURL">
				<xs:annotation>
					<xs:documentation>
						URL Prefix for viewing the feedback for a particular userid. Just add a userid.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyeBayURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for an eBay login page.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyeBayBiddingURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for viewing the items on which the user is bidding.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyeBayNotWonURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for viewing the items on which the user bid but did not win.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyeBayWonURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for viewing the items on which the user bid and also won.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MyeBayWatchingURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for viewing the items the user is currently watching.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="eBayStoreURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for eBay Stores.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="SmallLogoURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for the small version of the "An eBay Marketplace" logo.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="MediumLogoURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for the medium version of the "An eBay Marketplace" logo.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="LargeLogoURL">
				<xs:annotation>
					<xs:documentation>
						Full URL for the large version of the "An eBay Marketplace" logo.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/UnitCodeList.xsd #####

-->
	<xs:simpleType name="UnitCodeType">
		<xs:annotation>
			<xs:documentation>
				Units of measure used to express such properties as weight and size 
				dimensions.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="kg">
				<xs:annotation>
					<xs:documentation>
						(in/out) Kilograms
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="lbs">
				<xs:annotation>
					<xs:documentation>
						(in/out) Pounds
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="oz">
				<xs:annotation>
					<xs:documentation>
						(in/out) Ounces
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="cm">
				<xs:annotation>
					<xs:documentation>
						(in/out) Centimeters
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="inches">
				<xs:annotation>
					<xs:documentation>
						(in/out) Inches
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="ft">
				<xs:annotation>
					<xs:documentation>
						(in/out) Feet
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/UserConsentRequiredDefinitionType.xsd #####

-->
	<xs:complexType name="UserConsentRequiredDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the UserConsentRequired feature. If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/UserIDArrayType.xsd #####

-->
	<xs:complexType name="UserIDArrayType">
		<xs:annotation>
			<xs:documentation>
				Reserved for future use.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="UserID" type="ns:UserIDType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
				</xs:annotation>
			</xs:element>										
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/UserIDType.xsd #####

-->
	<xs:simpleType name="UserIDType">
		<xs:annotation>
			<xs:documentation>
				(out) An eBay ID that uniquely identifies a user.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/UserIdFilterType.xsd #####

-->
	<xs:complexType name="UserIdFilterType">
		<xs:annotation>
			<xs:documentation> 
        One of the data filters used when searching for items using
        GetSearchResults. Allows filtering based on the eBay user IDs of
        sellers. May be used to limit the list of found items to just those
        listed by one or more specified sellers. Or may be used to limit the
        list to those items NOT listed by specified excluded sellers.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="ExcludeSellers" type="ns:UserIDType" minOccurs="0" maxOccurs="100">
				<xs:annotation>
					<xs:documentation> 
            Specifies a list of one or more eBay user IDs that represent sellers whose item
            listings should NOT be returned in the search result set. That is, the sellers'
            items are excluded from the search results.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IncludeSellers" type="ns:UserIDType" minOccurs="0" maxOccurs="100">
				<xs:annotation>
					<xs:documentation> 
            Specifies a list of one or more eBay user IDs that represent sellers whose item
            listings are returned in the search result set (and only listings by the
            specified sellers. That is, the sellers' items are included in the search
            results.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetSearchResults</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/UserStatusCodeList.xsd #####

-->
	<xs:simpleType name="UserStatusCodeType">
		<xs:annotation>
			<xs:documentation>
UserStatusCodeType - Type declaration to be used by other schema.
These codes indicate the current state or status of a an eBay
user account.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="Unknown">
				<xs:annotation>
					<xs:documentation>
						     (out) User properties have never been set; this value should
						     seldom, if ever, be returned and typically represents a
						     problem
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Suspended">
				<xs:annotation>
					<xs:documentation>
						    (out) User has been suspended from selling and buying, such as
						    for violations of eBay terms or agreement
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Confirmed">
				<xs:annotation>
					<xs:documentation>
						   (out) User has completed online registration and has properly
						   responded to confirmation email; most users should fall
						   in this category
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Unconfirmed">
				<xs:annotation>
					<xs:documentation>
						    (out) User has completed online registration, but has either
						    not responded to confirmation email or has not yet been
						    sent the confirmation email
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Ghost">
				<xs:annotation>
					<xs:documentation>
						    (out) Registered users of AuctionWeb (pre-eBay) who never
						    re-registered on eBay
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="InMaintenance">
				<xs:annotation>
					<xs:documentation>
						    (out) Temporary user record state indicating the record is in
						    the process of being changed by eBay; query user
						    information again to get new status
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Deleted">
				<xs:annotation>
					<xs:documentation>
						    (out) Records for the specified user have been deleted
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardVerify">
				<xs:annotation>
					<xs:documentation>
						    (out) User has completed registration and confirmation, but is
						    pending a verification of credit card information
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="AccountOnHold">
				<xs:annotation>
					<xs:documentation>
						    (out) User's account is on hold, such as for non-payment of
						    amounts due eBay; user cannot sell or buy items
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Merged">
				<xs:annotation>
					<xs:documentation>
						      (out) User record has been merged with another account record
						      for the same user
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="RegistrationCodeMailOut">
				<xs:annotation>
					<xs:documentation>
						    (out) User has completed online registration and has been sent
						    the confirmation email, but has not yet responded to the
						    confirmation email
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="TermPending">
				<xs:annotation>
					<xs:documentation>
						      (out) User has been scheduled for account closure (typically
						      when a user has requested to have their account closed)
						      A user in this state should not be considered an active
						      user
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UnconfirmedHalfOptIn">
				<xs:annotation>
					<xs:documentation>
						      (out) User has completed the registration for Half.com and opted
						      to automatically also be registered with eBay, but the
						      registration confirmation is still pending
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardVerifyHalfOptIn">
				<xs:annotation>
					<xs:documentation>
						      (out) User has completed the registration for Half.com and opted
						      to automatically also be registered with eBay, but the
						      verification of credit card information is still pending
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UnconfirmedPassport">
				<xs:annotation>
					<xs:documentation>
						      (out) Obsolete; signing in with Microsoft Passport is no longer supported
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Obsolete</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CreditCardVerifyPassport">
				<xs:annotation>
					<xs:documentation>
						     (out) Obsolete; signing in with Microsoft Passport is no longer supported
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Obsolete</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="UnconfirmedExpress">
				<xs:annotation>
					<xs:documentation>
						     (out) Half.com User; user has completed the registration for Half.com
						     and opted to automatically also be registered with eBay, but the
						     registration confirmation is still pending
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						  (out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/UserType.xsd #####

-->
	<xs:complexType name="UserType">
		<xs:annotation>
			<xs:documentation>
				Type to contain the data for one eBay user. Depending on the context, the user
				might be the seller or the buyer in a transaction, or the bidder or winning bidder
				in a listing. An object of this type is returned by a number of calls, including
				the GetUser call.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="AboutMePage" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the user has set up an About Me page.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="EIASToken" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique identifier for the user that does not change when the eBay user name
						is changed. Use when an application needs to associate a new eBay user name
						with the corresponding eBay user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RESTToken" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						REST token (if available) for the user who is making the request. Not returned
						when UserID is for a different user than the one identified in eBayAuthToken.
						Use the REST token to authenticate REST API calls. For more information about
						REST tokens and the REST API, see http://developer.ebay.com/rest/.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<DetailLevels>ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Email" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Email address for the user. You cannot retrieve an email address for any user
						with whom you do not have a transactional relationship, regardless of site.
						Email is only returned for applicable calls when you are retrieving your own
						user data OR when you and the other user are in a transactional relationship
						and the call is being executed within a certain amount of time after the
						transaction is created. Based on Trust and Safety policies, the time is
						unspecified and can vary by site.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBestOffers</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<CallName>GetOrders</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>Seller</Context>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackScore" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The aggregate feedback score for a user. A user's feedback score is the net
						positive feedback minus the net negative feedback left for the user. Feedback
						scores are a quantitative expression of the desirability of dealing with a
						user as a buyer or a seller in transactions. Each transaction can result in
						one feedback entry for a given user (the buyer can leave feedback for the
						seller, and the seller can leave feedback for the buyer.). That one feedback
						can be positive, negative, or neutral. The aggregated feedback counts for a
						particular user represent that user's overall feedback score (referred to as a
						"feedback rating" on the eBay site). If the user has chosen to make their
						feedback private and that user is not the user identified in the request's
						authentication token, FeedbackScore is not returned and FeedbackPrivate is
						returned with a value of true.&lt;br&gt;
						&lt;br&gt;
						To be eligible to list on Express, a seller's feedback score needs to be 100 or higher.
						See "eBay Express" in the eBay Web Services guide.
						In GetSearchResultsExpress, only returned when ItemDetails is set to Fine.&lt;br&gt;
						&lt;br&gt;
						In GetSearchResults and GetCategoryListings, feedback information is only
						returned if IncludeFeedback = true in the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetHighBidders</CallName>
							<CallName>GetUser</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetBestOffers</CallName>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UniqueNegativeFeedbackCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Total count of negative feedback entries from unique (distinct) users.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UniquePositiveFeedbackCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Total count of positive feedback entries from unique (distinct) users.
						Contains the aggregate feedback score for a user. A member's feedback score is
						the net positive feedback minus the net negative feedback left for the member.
						Feedback scores are a quantitative expression of the desirability of dealing
						with that person as a Buyer or a Seller in auction transactions. Each auction
						transaction can result in one feedback entry for a given user (the buyer can
						leave feedback for the seller, and the seller can leave feedback for the
						buyer.). That one feedback can be positive, negative, or neutral. The
						aggregated feedback counts for a particular user represent that user's overall
						feedback score (referred to as a "feedback rating" on the eBay site). This
						rating is commonly expressed as the eBay Feedback score for the user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PositiveFeedbackPercent" type="xs:float" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Percent of total feedback that is positive. For example, if the member has 50
						feedbacks, where 49 are positive and 1 is neutral or negative, the positive
						feedback percent could be 98.0. The value uses a max precision of 4 and a
						scale of 1. If the user has feedback, this value can be returned regardless of
						whether the member has chosen to make their feedback private. Not returned if
						the user has no feedback. To be eligible to list on Express, a seller's
						feedback percent needs to be 98 or higher. See "eBay Express" in the eBay Web
						Services guide. In GetSearchResults and GetCategoryListings, feedback
						information is only returned if IncludeFeedback = true in the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackPrivate" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the user has chosen to make their feedback score and
						feedback details private (hidden from other users). Note that the percentage
						of positive feedback can still be returned, even if other feedback details are
						private. To be eligible to list on Express, a seller's feedback needs to be
						public. See "eBay Express" in the eBay Web Services guide. In GetSearchResults
						and GetCategoryListings, feedback information is only returned if
						IncludeFeedback = true in the request.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FeedbackRatingStar" type="ns:FeedbackRatingStarCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Visual indicator of user's feedback score. See FeedbackRatingStarCodeType for
						specific values.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="IDVerified" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether the user has been verified. For more information
						about the ID Verify program, see:
						http://pages.ebay.com/help/policies/identity-idverify.html
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="eBayGoodStanding" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, indicates that the user is in good standing with eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="NewUser" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, identifies a new user who has been a registered eBay user for 30 days
						or less. Always false after the user has been registered for more than 30
						days. Does not indicate an ID change (see UserIdChanged).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RegistrationAddress" type="ns:AddressType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Registration address for a user. eBay always returns complete
						RegistrationAddress details (including Phone) when you retrieve your own user
						data. RegistrationAddress for another user (except for Phone) is only returned
						if you have a transactional relationship with that user AND that user is
						registered on DE/AT/CH, regardless of your registration site and the site to
						which you send the request. To be eligible to list on Express US, a seller's
						registration address must be in the US or Canada. To list on Express Germany,
						a seller's registration address must be in Germany. See "eBay Express" in the
						eBay Web Services guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RegistrationDate" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the date the specified user originally registered with eBay.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBestOffers</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Site" type="ns:SiteCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						eBay site the user is registered with.
						To be eligible to list on Express US, a seller must be registered
						on the eBay US or Canada site. To be eligible to list on Express Germany,
						a seller must registered on the eBay Germany site. See "eBay Express"
						in the eBay Web Services guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Status" type="ns:UserStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates the user's registration/user status.
						To be eligible to list on Express, a seller's status must be Confirmed.
						See "eBay Express" in the eBay Web Services guide.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserID" type="ns:UserIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Unique eBay user ID for the user.&lt;br&gt;
						&lt;br&gt;
						In GetSearchResultsExpress, only returned when ItemDetails is set to Fine.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>PlaceOffer</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBestOffers</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemsAwaitingFeedback</CallName>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BestOfferList</Context>
							<Context>HighBidder</Context>
							<Context>LostList</Context>
							<Context>Seller</Context>
							<Context>WonList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>ActiveList</Context>
							<Context>SoldList</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetSearchResultsExpress</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerEvents</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserIDChanged" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If true, identifies a user whose ID has changed within the last 30 days. Does not
						indicate a new user (see NewUser).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserIDLastChanged" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Date and time the user's data was last changed (in GMT).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VATStatus" type="ns:VATStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether or not the user is subject to VAT.
						Users who have registered with eBay as VAT-exempt are not
						subject to VAT. See documentation on Value-Added Tax (VAT).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="BuyerInfo" type="ns:BuyerType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains information about the user as a buyer, such as
						the shipping address. See BuyerType for its child elements.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetHighBidders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
							<Context>Bidder</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrderTransactions</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<Context>HighBidder</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
							<Context>Buyer</Context>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<Context>SoldList</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerInfo" type="ns:SellerType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains information about the user as a seller, such as whether the seller is
						authorized to list Live Auctions items or opts to have items cross-promoted. See
						SellerType for its child elements.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Always</Returned>
							<Context>Seller</Context>
							<DetailLevels>none, ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
							<Context>Seller</Context>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharityAffiliations" type="ns:CharityAffiliationsType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains information about the seller's charity affliations. Returned if the
						user is affiliated with one or more charities.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="CharitySeller" type="ns:CharitySellerType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains information about the seller with the eBay Giving Works provider
						charity seller account.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalAccountLevel" type="ns:PayPalAccountLevelCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The user's PayPal account level. Only returned for the user identified in
						eBayAuthToken. That is, you cannot see someone else's PayPal account level.
						Use this information to check whether a seller is eligible to specify
						Item.DigitalDeliveryDetails in listing requests. See the eBay Web site online
						help for current PayPal requirements for listing digital items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalAccountType" type="ns:PayPalAccountTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The user's PayPal account type. Only returned for the user identified in
						eBayAuthToken. That is, you cannot see someone else's PayPal account type. Use
						this information to check whether a seller is likely to be eligible to specify
						Item.DigitalDeliveryDetails in listing requests. See the eBay Web site online
						help for current PayPal requirements for listing digital items. Please note
						that this information cannot necessarily be used to determine whether a seller
						is eligible to list items on eBay Express, because a seller can have more than
						one PayPal account (and any of these accounts can be used for a given
						listing).
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PayPalAccountStatus" type="ns:PayPalAccountStatusCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The user's PayPal account status. Only returned for the user identified in
						eBayAuthToken. That is, you cannot see someone else's PayPal account status.
						Use this information to check whether a seller is eligible to specify
						Item.DigitalDeliveryDetails in listing requests. See the eBay Web site online
						help for current PayPal requirements for listing digital items.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="UserSubscription" type="ns:EBaySubscriptionTypeCodeType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Specifies the subscription level for a user.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SiteVerified" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						If the user is a registered eBay China site user, this indicates whether the
						user has been verified. This value is based on the user's registration site,
						not the site that was specified in the request. If true, the China site user
						is verified. If false, the China site user is unverified. Not applicable to
						users who are not registered China site users.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAllBidders</CallName>
							<CallName>GetBidderList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItemTransactions</CallName>
							<CallName>GetSellerTransactions</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SkypeID" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						Indicates the Skype name of the user. Available if
						the seller has a Skype account and has linked it (on the eBay site)
						with his or her eBay account.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="eBayWikiReadOnly" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Indicates whether a user has read-only access to the eBay Wiki (true)
						or whether the user is able contribute or edit articles on the eBay Wiki
						(false). By default, all registered eBay users have access to contribute and
						edit articles on the eBay Wiki. All content contributed to the eBay Wiki is
						subject to the Community Content Policy.
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<CallInfo>
							<CallName>GetUser</CallName>
							<DetailLevels>none, ReturnAll</DetailLevels>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="TUVLevel" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VATID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MotorsDealer" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<CallName>GetSellerList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<Context>Seller</Context>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SellerPaymentMethod" type="ns:SellerPaymentMethodCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Reserved for future use.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetUser</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/VATDetailsType.xsd #####

-->
	<xs:complexType name="VATDetailsType">
		<xs:annotation>
			<xs:documentation> 
             Container for eBay's Business User features. A business seller can choose 
             to offer an item exclusively to bidders and buyers that also represent businesses.
             Only applicable when the item is listed in a B2B-enabled category. 
             Currently, the eBay Germany (DE), Austria (AT), and Switzerland (CH) sites support
             B2B business features.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="BusinessSeller" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						(in) If true, this indicates that the seller is a business user 
						and intends to use listing features that are offered to 
						business users only. Applicable only to business sellers 
						residing in Germany, Austria, or Switzerland who are listing in 
						a B2B VAT- enabled category on the eBay Germany (DE), Austria 
						(AT), or Switzerland (CH) sites. The seller must have a valid 
						VAT ID registered with eBay. This must be set to true if 
						RestrictedToBusiness is true. It has no effect if 
						RestrictedToBusiness is false. If an item was not qualified as a 
						business item when originally listed, but meets the conditions for 
						business items when the item is revised or relisted, the seller can 
						convert the item to a business item by specifying the appropriate 
						VAT details. See the eBay Web Services guide for more information and additional rules.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>							
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>					
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="RestrictedToBusiness" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						If true, this indicates that the seller elects to offer the 
						item exclusively to business users. If false, this indicates 
						that the seller elects to offer the item to all users. 
						Applicable only to business sellers residing in Germany, 
						Austria, or Switzerland who are listing in a B2B VAT-enabled 
						category on the eBay Germany (DE), Austria (AT), or Switzerland 
						(CH) sites. If this argument is true, the seller must have a 
						valid VAT-ID registered with eBay, and BusinessSeller must also 
						be true. 
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>							
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="VATPercent" type="xs:float" minOccurs="0">
				<xs:annotation>
					<xs:documentation> 
						VAT rate for the item. When the VATPercent is specified, the 
						item's VAT information appears on the item's listing page. In 
						addition, the seller can choose to print an invoice that 
						includes the item's net price, VAT percent, VAT amount, and 
						total price. Since VAT rates vary 
						depending on the item and on the user's country of residence, a 
						seller is responsible for entering the correct VAT rate; it is 
						not calculated by eBay. To specify a VATPercent, a seller must 
						have a VAT-ID registered with eBay and must be listing the item on a VAT-enabled site.
						Max precision 3 
						decimal places. Max length 5 characters. Note: The View Item 
						page displays the precision to 2 decimal places with no 
						trailing zeros. However, the full value you send in is stored.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/VATStatusCodeList.xsd #####

-->
	<xs:simpleType name="VATStatusCodeType">
		<xs:annotation>
			<xs:documentation>
				Indicates whether or not the user is subject to VAT.
				Users who have registered with eBay as VAT-exempt are not
				subject to VAT. See documentation on Value-Added Tax (VAT).
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:token">
			<xs:enumeration value="NoVATTax">
				<xs:annotation>
					<xs:documentation>
						(out) VAT is not applicable
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATTax">
				<xs:annotation>
					<xs:documentation>
						(out) Residence in a country with VAT and user is not registered as VAT-exempt
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="VATExempt">
				<xs:annotation>
					<xs:documentation>
						(out) Residence in a country with VAT and user is registered as VAT-exempt
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CustomCode">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for internal or future use
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/ValType.xsd #####

-->
	<xs:complexType name="ValType">
		<xs:sequence>
			<xs:element name="ValueLiteral" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The descriptive name of an attribute or characteristic value
						(e.g., "New" might be a literal value for a Condition
						attribute). In item-listing requests, if you send ValueID with
						an id of -3 or -6, you must use ValueLiteral to enter the value the user
						specified. Otherwise, eBay treats the request as if no value
						was sent at all. For eBay.com listings,
						use AttributeSetArray.AttributeSet.Attribute.Value.ValueLiteral.
						The max length allowed varies per attribute.
						&lt;br&gt;&lt;br&gt;
						For Half.com, use AttributeArray.Attribute.Value.ValueLiteral.
						That is, the parent elements and usage for Half.com differs
						from eBay's standard Item Specifics format (and there is no
						relationship to GetAttributesCS). For Half.com,
						AttributeArray.Attribute.Value.ValueLiteral is required when
						you use AddItem. See the eBay Web Services Guide for valid
						values. For the Half.com Notes attribute, the max
						length is 500 characters. You can revise
						AttributeArray.Attribute.Value.ValueLiteral for Half.com
						listings.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>see description</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetProductSearchResults</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetOrders</CallName>
							<Returned>Always</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SuggestedValueLiteral" type="xs:string" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(out) Reserved for future use. Suggested alternative text for
						ValueLiteral. Multiple SuggestedValueLiteral elements can be
						returned in a Value node. Not applicable to Half.com.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ValueID" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Constant value that identifies the attribute or characteristic
						in a language-independent way. Unique within the
						characteristics set. In item-listing requests, if the ID is -3
						or -6 (Other), use ValueLiteral to specify the value that the
						user entered. In item-listing requests and product searches,
						the possible ID values are:&lt;br&gt;
						-3 = User entered an arbitrary value (not an "Other" field)&lt;br&gt;
						-6 = User entered a value in an "Other" field&lt;br&gt;
						-100 = Value not specified (null)&lt;br&gt;
						#### (positive integer) = Identifier for a pre-defined value
						that the user selected (e.g., 1001)&lt;br&gt;
						For eBay.com, required if ValueList is specified.
						Not applicable to Half.com.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetProductSearchResults</CallName>
							<CallName>GetSearchResults</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<Context>AttributeSetArray</Context>
							<RequiredInput>Conditionally</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetProductFamilyMembers</CallName>
							<CallName>GetProductSearchResults</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/ValuePackEnabledDefinitionType.xsd #####

-->
	<xs:complexType name="ValuePackEnabledDefinitionType">
		<xs:annotation>
			<xs:documentation> 
				Defines the ValuePack feature (a feature pack). If the field is present, the corresponding feature applies to the category. The field is returned as an empty element (i.e., a boolean value is not returned).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/VendorHostedPictureType.xsd #####

-->
	<xs:complexType name="VendorHostedPictureType">
		<xs:annotation>
			<xs:documentation>
				Data for images hosted on a location of the seller's choice (other than eBay).
				Specify 1 PictureURL value and up to 5 SelfHostedURL values. With compatibility
				level 439 and higher, deprecated in the response in favor of Item.PictureDetails.
				With the future deprecation of VendorHostedPicture as input, Applications should
				use Item.PictureDetails instead.
				&lt;br&gt;&lt;br&gt;
				Note that the Gallery Plus image enhancement does not support
				VendorHostedPicture. Use Item.PictureDetails with that feature.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="PictureURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) Deprecated with compatibility level 383 and higher.
						Contains the URL for an image hosted on a location of the seller's
						choice (other than eBay) and associated with an item. If specified,
						this cannot have an empty/null value. You cannot specify multiple
						PictureURL fields. In most cases, the picture URL is also used for
						the picture at the top of the View Item page on the Web site.&lt;br&gt;
						For listing calls (e.g., AddItem):&lt;br&gt;
						With compatibility levels lower than 383, specify 1 PictureURL argument.&lt;br&gt;
						With compatibility 383 and higher, see SelfHostedURL instead.&lt;br&gt;
						With the future deprecation of VendorHostedPicture as input,
						applications should use Item.PictureDetails.PictureURL instead. See
						Item.PictureDetails.PictureURL for information about how to remove
						pictures from a listing.&lt;br&gt;
						For retrieval calls (e.g., GetItem):&lt;br&gt;
						With compatibility levels lower than 383, PictureURL is returned.&lt;br&gt;
						With compatibility levels between 383 and 439, SelfHostedURL is returned instead.&lt;br&gt;
						With compatibility 439 and higher,  Item.PictureDetails.PictureURL is returned instead.
						&lt;br&gt;&lt;br&gt;
						Note that the Gallery Plus image enhancement does not support
						VendorHostedPicture. Use Item.PictureDetails with that feature.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="SelfHostedURL" type="xs:anyURI" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation>
						(in/out) URL for multiple, self-hosted pictures (if any) that are
						stored/hosted at a non-eBay site and used for the item. If
						specified, do not pass an empty/null value. On the main eBay site,
						if you specify multiple SelfHostedURL fields in listing calls,
						PhotoDisplay must be set to VendorHostedPictureShow.&lt;br&gt;
						For listing calls (e.g., AddItem):&lt;br&gt;
						With compatibility levels lower than 383, specify 1 PictureURL field.&lt;br&gt;
						With compatibility 383 and higher, specify up to 6 SelfHostedURL fields.&lt;br&gt;
						For eBay Live Auctions, specify up to 5 SelfHostedURL fields. With
						the future deprecation of VendorHostedPicture as input, Applications
						should use Item.PictureDetails.PictureURL instead.&lt;br&gt;
						For retrieval calls (e.g., GetItem):&lt;br&gt;
						With compatibility levels lower than 383, PictureURL is returned.&lt;br&gt;
						With compatibility levels between 383 and 439, SelfHostedURL is returned.&lt;br&gt;
						With compatibility 439 and higher,  Item.PictureDetails.PictureURL is returned.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>150</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PhotoDisplay" type="ns:PhotoDisplayCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					Specifies the type of image display used in a listing. Some options are
					only available if images are hosted through eBay Picture Services (EPS).
					eBay determines this by parsing the associated PictureURL.
					Cannot be used in combination with Listing Designer layouts.
					Specify None or do not add PhotoDisplay when ListingDesigner.LayoutID
					is a value other than 0.
					</xs:documentation>
						<xs:appinfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
						</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GalleryURL" type="xs:anyURI" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						URL for a picture to be used as the Gallery thumbnail. Ignored if
						GalleryType is None or unspecified. If the value of GalleryType is
						Gallery or Featured, you can either specify GalleryURL or allow eBay
						to use another picture that you have included in the listing. (See
						GalleryType for the rules that determine which URL is used if you do
						not specify GalleryURL.) The image used for the Gallery thumbnail
						must be in one of the graphics formats JPEG, BMP, TIF, or GIF. eBay
						Live Auctions lots are listed in the gallery for free. With the
						future deprecation of VendorHostedPicture as input, Applications
						should use Item.PictureDetails.GalleryURL instead. If the item has
						bids (or items have been sold) or the listing ends within 12 hours,
						you can add GalleryURL or change its value, but you cannot remove
						the gallery picture if it was previously specified. Not applicable
						to eBay Motors listings. See "Describing Items in a Listing" in the
						If the value of GalleryType is Gallery or Plus or Featured,
						see eBay Web Services Guide for additional validation rules.
						&lt;br&gt;&lt;br&gt;
						Note that the Gallery Plus image enhancement does not support
						VendorHostedPicture. Use Item.PictureDetails with that feature.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>1024</MaxLength>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>AddLiveAuctionItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>ReviseLiveAuctionItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetMyeBayBuying</CallName>
							<Returned>Conditionally</Returned>
							<Context>BidList</Context>
							<Context>SecondChanceOffer</Context>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ReturnSummary, ReturnAll</DetailLevels>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
							<DetailLevels>none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="GalleryType" type="ns:GalleryTypeCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            Indicates whether a picture for the item is included in the Gallery and, if so
				whether the item is also featured or Plus in the Gallery.
				If the value is Gallery or Plus or Featured, eBay checks the available image URLs
				in the following order to determine which URL to use
				(if more than one of these URLs is available):&lt;br&gt;&lt;br&gt;
            a) Use the URL in GalleryURL, if it is specified.&lt;br&gt;
            b) Otherwise, if ProductListingDetails.UseStockPhotoURLAsGallery is true, use the eBay stock photo.&lt;br&gt;
            c) Otherwise, use the value of the first SelfHostedURL in the array of SelfHostedURL fields, if any.&lt;br&gt;
            d) Otherwise, if ProductListingDetails.ProductID is specified, use the eBay stock photo
               (eBay resets UseStockPhotoURLAsGallery to true in this case).&lt;br&gt;
            e) If eBay is unable to find an image URL for the listing, an error is returned.&lt;br&gt;&lt;br&gt;
            See "Describing Items in a Listing" in the eBay Web Services Guide for additional information
            about working with pictures and related validation rules.
            You cannot remove Gallery or Plus or Featured when you revise a listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
							<DetailLevels>ItemReturnDescription, ReturnAll</DetailLevels>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetCategoryListings</CallName>
							<CallName>GetMyeBaySelling</CallName>
							<CallName>GetSearchResults</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
						<CallInfo>
							<CallName>GetItem</CallName>
							<Returned>Conditionally</Returned>
							<TagStatus>Deprecated</TagStatus>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/VerifiedUserRequirementsType.xsd #####

-->
	<xs:complexType name="VerifiedUserRequirementsType">
		<xs:annotation>
			<xs:documentation>
				Container for verified user requirements.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="VerifiedUser" type="xs:boolean" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) If true, blocks bidding by users who do not pass
						a simple check (for example, for credit card on file).
						See "Buyer Requirements - VerifiedUser" in the chapter
						"Field Differences for eBay Sites."
					</xs:documentation>
					<xs:appinfo>
						<Default>false</Default>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="MinimumFeedbackScore" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) This field is ignored unless VerifiedUser is true.
						If this field is present, the user's feedback score is also considered:
						a user is blocked from bidding if the user's feedback score is
						less than or equal to the value of this field.
					</xs:documentation>
					<xs:appinfo>
						<Min/>
						<Max/>
						<Default>5</Default>
						<CallInfo>
							<CallName>AddItem</CallName>
							<CallName>GetItemRecommendations</CallName>
							<CallName>RelistItem</CallName>
							<CallName>ReviseItem</CallName>
							<CallName>VerifyAddItem</CallName>
							<RequiredInput>No</RequiredInput>
						</CallInfo>
						<CallInfo>
							<CallName>GetBidderList</CallName>
							<CallName>GetItem</CallName>
							<CallName>GetSellerList</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/WantItNowPostArrayType.xsd #####

-->
	<xs:complexType name="WantItNowPostArrayType">
		<xs:annotation>
			<xs:documentation> 
				(out) Container for a list of search result items. Can contain zero, one, or multiple
				WantItNowPostType objects, each of which contains data for a single Want It Now 
				post found by the search.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="WantItNowPost" type="ns:WantItNowPostType" minOccurs="0" maxOccurs="unbounded">
				<xs:annotation>
					<xs:documentation> 
						(out) Contains data for a Want It Now post found by a search.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/WantItNowPostType.xsd #####

-->
	<xs:complexType name="WantItNowPostType">
		<xs:annotation>
			<xs:documentation>
				Contains the data describing a single Want It Now post. Buyers create Want It Now
				posts to communicate to sellers specific requirements for items they would like to
				buy.
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="CategoryID" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) ID of the category in which the Want It Now post is listed.
					</xs:documentation>
					<xs:appinfo>
						<MaxLength>10</MaxLength>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Description" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Description of a Want It Now post. Description will not be returned for
						GetWantItNowSearchResults.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="PostID" type="ns:ItemIDType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(in/out) ID that uniquely identifies a Want It Now post.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Site" type="ns:SiteCodeType" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Site where the Want It Now post is listed.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="StartTime" type="xs:dateTime" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Date and time (in GMT) that a Want It Now post was added.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="ResponseCount" type="xs:int" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						(out) Number of responses for a Want It Now post. Sellers respond to a Want It
						Now post by submitting an item number, so each response corresponds to an item
						listing.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="Title" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
					  (out) Title of a Want It Now post.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetWantItNowSearchResults</CallName>
							<Returned>Conditionally</Returned>
						</CallInfo>
						<CallInfo>
							<CallName>GetWantItNowPost</CallName>
							<Returned>Always</Returned>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/WirelessCarrierIDCodeList.xsd #####

-->
	<xs:simpleType name="WirelessCarrierIDCodeType">
		<xs:restriction base="xs:token">
			<xs:enumeration value="Cingular"/>
			<xs:enumeration value="TMobile"/>
			<xs:enumeration value="Sprint"/>
			<xs:enumeration value="Nextel"/>
			<xs:enumeration value="Verizon"/>
			<xs:enumeration value="CincinnatiBell"/>
			<xs:enumeration value="Dobson"/>
			<xs:enumeration value="Alltel"/>
			<xs:enumeration value="Leap"/>
			<xs:enumeration value="USCellular"/>
			<xs:enumeration value="Movistar"/>
			<xs:enumeration value="Amena"/>
			<xs:enumeration value="Vodafone"/>
			<xs:enumeration value="ATT"/>
			<xs:enumeration value="CustomCode"/>
		</xs:restriction>
	</xs:simpleType>
<!--  

##### from file eBLBaseComponents/public/XSLFileType.xsd #####

-->
	<xs:complexType name="XSLFileType">
		<xs:annotation>
			<xs:documentation>
				Describes an XSL file that would be returned
				from an Item Specifics or Pre-filled Item Information meta-data call
				(such as GetAttributesXSL or GetProductFinderXSL).
			</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="FileName" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						The name of the XSL file. Store this information to use it
						as input to the call in the future.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAttributesXSL</CallName>
							<CallName>GetProductFinderXSL</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FileVersion" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
            The version number of the XSL file. Store this information to use it
            as input to the call in the future.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAttributesXSL</CallName>
							<CallName>GetProductFinderXSL</CallName>
							<Returned>Always</Returned>
							<DetailLevels>none, ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:element name="FileContent" type="xs:string" minOccurs="0">
				<xs:annotation>
					<xs:documentation>
						Contains a MIME base-64-encoded representation of the XSL file.
						See the eBay Web Services Guide for information on decoding
						the XSL stylesheet file. If no XSL file is available (or if you passed no detail level),
						this property is empty or not returned.
					</xs:documentation>
					<xs:appinfo>
						<CallInfo>
							<CallName>GetAttributesXSL</CallName>
							<CallName>GetProductFinderXSL</CallName>
							<Returned>Always</Returned>
							<DetailLevels>ReturnAll</DetailLevels>
						</CallInfo>
					</xs:appinfo>
				</xs:annotation>
			</xs:element>
			<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>
<!--  

##### from file eBLBaseComponents/public/eBxOptInPreferenceType.xsd #####

-->
	<xs:complexType name="eBxOptInPreferenceType">
	<xs:annotation>
		<xs:documentation>
			Contains a seller's preferences for listing items on Ebay Express.
		</xs:documentation>
	</xs:annotation>
	<xs:sequence>
		<xs:element name="eBxOptInPreference" type="xs:boolean" minOccurs="0">
			<xs:annotation>
				<xs:documentation>
					If true: The seller wants their eligible eBay listings to be included on
					eBay Express (in addition to the main eBay site). If false: The seller
					does not want their listings to be included on eBay Express. If omitted
					(in SetUserPreferences): The seller does not want to change their
					existing preference. (Initially, eBay sets this preference to true for
					every seller.)
				</xs:documentation>
				<xs:appinfo>
					<CallInfo>
						<CallName>GetUserPreferences</CallName>
						<TagStatus>Deprecated</TagStatus>
						<Returned>Conditionally</Returned>
					</CallInfo>
					<CallInfo>
						<CallName>SetUserPreferences</CallName>
						<Default>omitted</Default>
						<TagStatus>ObsoleteSoon</TagStatus>
						<RequiredInput>No</RequiredInput>
					</CallInfo>
				</xs:appinfo>
			</xs:annotation>
		</xs:element>
		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
	</xs:sequence>
</xs:complexType>


		</xs:schema>
	</wsdl:types>
	<wsdl:message name="RequesterCredentials">
		<wsdl:part name="RequesterCredentials" element="ns:RequesterCredentials"/>
	</wsdl:message>
	
	<wsdl:message name="AddDisputeResponse">
		<wsdl:part name="AddDisputeResponse" element="ns:AddDisputeResponse"/>
	</wsdl:message>
	<wsdl:message name="AddDisputeRequest">
		<wsdl:part name="AddDisputeRequest" element="ns:AddDisputeRequest"/>
	</wsdl:message>
	<wsdl:message name="AddDisputeResponseResponse">
		<wsdl:part name="AddDisputeResponseResponse" element="ns:AddDisputeResponseResponse"/>
	</wsdl:message>
	<wsdl:message name="AddDisputeResponseRequest">
		<wsdl:part name="AddDisputeResponseRequest" element="ns:AddDisputeResponseRequest"/>
	</wsdl:message>
	<wsdl:message name="AddItemResponse">
		<wsdl:part name="AddItemResponse" element="ns:AddItemResponse"/>
	</wsdl:message>
	<wsdl:message name="AddItemRequest">
		<wsdl:part name="AddItemRequest" element="ns:AddItemRequest"/>
	</wsdl:message>
	<wsdl:message name="AddLiveAuctionItemResponse">
		<wsdl:part name="AddLiveAuctionItemResponse" element="ns:AddLiveAuctionItemResponse"/>
	</wsdl:message>
	<wsdl:message name="AddLiveAuctionItemRequest">
		<wsdl:part name="AddLiveAuctionItemRequest" element="ns:AddLiveAuctionItemRequest"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessageResponse">
		<wsdl:part name="AddMemberMessageResponse" element="ns:AddMemberMessageResponse"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessageRequest">
		<wsdl:part name="AddMemberMessageRequest" element="ns:AddMemberMessageRequest"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessageAAQToPartnerResponse">
		<wsdl:part name="AddMemberMessageAAQToPartnerResponse" element="ns:AddMemberMessageAAQToPartnerResponse"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessageAAQToPartnerRequest">
		<wsdl:part name="AddMemberMessageAAQToPartnerRequest" element="ns:AddMemberMessageAAQToPartnerRequest"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessageRTQResponse">
		<wsdl:part name="AddMemberMessageRTQResponse" element="ns:AddMemberMessageRTQResponse"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessageRTQRequest">
		<wsdl:part name="AddMemberMessageRTQRequest" element="ns:AddMemberMessageRTQRequest"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessagesAAQToBidderResponse">
		<wsdl:part name="AddMemberMessagesAAQToBidderResponse" element="ns:AddMemberMessagesAAQToBidderResponse"/>
	</wsdl:message>
	<wsdl:message name="AddMemberMessagesAAQToBidderRequest">
		<wsdl:part name="AddMemberMessagesAAQToBidderRequest" element="ns:AddMemberMessagesAAQToBidderRequest"/>
	</wsdl:message>
	<wsdl:message name="AddOrderResponse">
		<wsdl:part name="AddOrderResponse" element="ns:AddOrderResponse"/>
	</wsdl:message>
	<wsdl:message name="AddOrderRequest">
		<wsdl:part name="AddOrderRequest" element="ns:AddOrderRequest"/>
	</wsdl:message>
	<wsdl:message name="AddSecondChanceItemResponse">
		<wsdl:part name="AddSecondChanceItemResponse" element="ns:AddSecondChanceItemResponse"/>
	</wsdl:message>
	<wsdl:message name="AddSecondChanceItemRequest">
		<wsdl:part name="AddSecondChanceItemRequest" element="ns:AddSecondChanceItemRequest"/>
	</wsdl:message>
	<wsdl:message name="AddToItemDescriptionResponse">
		<wsdl:part name="AddToItemDescriptionResponse" element="ns:AddToItemDescriptionResponse"/>
	</wsdl:message>
	<wsdl:message name="AddToItemDescriptionRequest">
		<wsdl:part name="AddToItemDescriptionRequest" element="ns:AddToItemDescriptionRequest"/>
	</wsdl:message>
	<wsdl:message name="AddToWatchListResponse">
		<wsdl:part name="AddToWatchListResponse" element="ns:AddToWatchListResponse"/>
	</wsdl:message>
	<wsdl:message name="AddToWatchListRequest">
		<wsdl:part name="AddToWatchListRequest" element="ns:AddToWatchListRequest"/>
	</wsdl:message>
	<wsdl:message name="AddTransactionConfirmationItemResponse">
		<wsdl:part name="AddTransactionConfirmationItemResponse" element="ns:AddTransactionConfirmationItemResponse"/>
	</wsdl:message>
	<wsdl:message name="AddTransactionConfirmationItemRequest">
		<wsdl:part name="AddTransactionConfirmationItemRequest" element="ns:AddTransactionConfirmationItemRequest"/>
	</wsdl:message>
	<wsdl:message name="ApproveLiveAuctionBiddersResponse">
		<wsdl:part name="ApproveLiveAuctionBiddersResponse" element="ns:ApproveLiveAuctionBiddersResponse"/>
	</wsdl:message>
	<wsdl:message name="ApproveLiveAuctionBiddersRequest">
		<wsdl:part name="ApproveLiveAuctionBiddersRequest" element="ns:ApproveLiveAuctionBiddersRequest"/>
	</wsdl:message>
	<wsdl:message name="CompleteSaleResponse">
		<wsdl:part name="CompleteSaleResponse" element="ns:CompleteSaleResponse"/>
	</wsdl:message>
	<wsdl:message name="CompleteSaleRequest">
		<wsdl:part name="CompleteSaleRequest" element="ns:CompleteSaleRequest"/>
	</wsdl:message>
	<wsdl:message name="DeleteMyMessagesResponse">
		<wsdl:part name="DeleteMyMessagesResponse" element="ns:DeleteMyMessagesResponse"/>
	</wsdl:message>
	<wsdl:message name="DeleteMyMessagesRequest">
		<wsdl:part name="DeleteMyMessagesRequest" element="ns:DeleteMyMessagesRequest"/>
	</wsdl:message>
	<wsdl:message name="EndItemResponse">
		<wsdl:part name="EndItemResponse" element="ns:EndItemResponse"/>
	</wsdl:message>
	<wsdl:message name="EndItemRequest">
		<wsdl:part name="EndItemRequest" element="ns:EndItemRequest"/>
	</wsdl:message>
	<wsdl:message name="FetchTokenResponse">
		<wsdl:part name="FetchTokenResponse" element="ns:FetchTokenResponse"/>
	</wsdl:message>
	<wsdl:message name="FetchTokenRequest">
		<wsdl:part name="FetchTokenRequest" element="ns:FetchTokenRequest"/>
	</wsdl:message>
	<wsdl:message name="GetAccountResponse">
		<wsdl:part name="GetAccountResponse" element="ns:GetAccountResponse"/>
	</wsdl:message>
	<wsdl:message name="GetAccountRequest">
		<wsdl:part name="GetAccountRequest" element="ns:GetAccountRequest"/>
	</wsdl:message>
	<wsdl:message name="GetAdFormatLeadsResponse">
		<wsdl:part name="GetAdFormatLeadsResponse" element="ns:GetAdFormatLeadsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetAdFormatLeadsRequest">
		<wsdl:part name="GetAdFormatLeadsRequest" element="ns:GetAdFormatLeadsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetAllBiddersResponse">
		<wsdl:part name="GetAllBiddersResponse" element="ns:GetAllBiddersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetAllBiddersRequest">
		<wsdl:part name="GetAllBiddersRequest" element="ns:GetAllBiddersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetApiAccessRulesResponse">
		<wsdl:part name="GetApiAccessRulesResponse" element="ns:GetApiAccessRulesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetApiAccessRulesRequest">
		<wsdl:part name="GetApiAccessRulesRequest" element="ns:GetApiAccessRulesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetAttributesCSResponse">
		<wsdl:part name="GetAttributesCSResponse" element="ns:GetAttributesCSResponse"/>
	</wsdl:message>
	<wsdl:message name="GetAttributesCSRequest">
		<wsdl:part name="GetAttributesCSRequest" element="ns:GetAttributesCSRequest"/>
	</wsdl:message>
	<wsdl:message name="GetAttributesXSLResponse">
		<wsdl:part name="GetAttributesXSLResponse" element="ns:GetAttributesXSLResponse"/>
	</wsdl:message>
	<wsdl:message name="GetAttributesXSLRequest">
		<wsdl:part name="GetAttributesXSLRequest" element="ns:GetAttributesXSLRequest"/>
	</wsdl:message>
	<wsdl:message name="GetBestOffersResponse">
		<wsdl:part name="GetBestOffersResponse" element="ns:GetBestOffersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetBestOffersRequest">
		<wsdl:part name="GetBestOffersRequest" element="ns:GetBestOffersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetBidderListResponse">
		<wsdl:part name="GetBidderListResponse" element="ns:GetBidderListResponse"/>
	</wsdl:message>
	<wsdl:message name="GetBidderListRequest">
		<wsdl:part name="GetBidderListRequest" element="ns:GetBidderListRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCategoriesResponse">
		<wsdl:part name="GetCategoriesResponse" element="ns:GetCategoriesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCategoriesRequest">
		<wsdl:part name="GetCategoriesRequest" element="ns:GetCategoriesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCategory2CSResponse">
		<wsdl:part name="GetCategory2CSResponse" element="ns:GetCategory2CSResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCategory2CSRequest">
		<wsdl:part name="GetCategory2CSRequest" element="ns:GetCategory2CSRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCategory2FinanceOfferResponse">
		<wsdl:part name="GetCategory2FinanceOfferResponse" element="ns:GetCategory2FinanceOfferResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCategory2FinanceOfferRequest">
		<wsdl:part name="GetCategory2FinanceOfferRequest" element="ns:GetCategory2FinanceOfferRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCategoryFeaturesResponse">
		<wsdl:part name="GetCategoryFeaturesResponse" element="ns:GetCategoryFeaturesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCategoryFeaturesRequest">
		<wsdl:part name="GetCategoryFeaturesRequest" element="ns:GetCategoryFeaturesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCategoryListingsResponse">
		<wsdl:part name="GetCategoryListingsResponse" element="ns:GetCategoryListingsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCategoryListingsRequest">
		<wsdl:part name="GetCategoryListingsRequest" element="ns:GetCategoryListingsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCategoryMappingsResponse">
		<wsdl:part name="GetCategoryMappingsResponse" element="ns:GetCategoryMappingsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCategoryMappingsRequest">
		<wsdl:part name="GetCategoryMappingsRequest" element="ns:GetCategoryMappingsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCharitiesResponse">
		<wsdl:part name="GetCharitiesResponse" element="ns:GetCharitiesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCharitiesRequest">
		<wsdl:part name="GetCharitiesRequest" element="ns:GetCharitiesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetContextualKeywordsResponse">
		<wsdl:part name="GetContextualKeywordsResponse" element="ns:GetContextualKeywordsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetContextualKeywordsRequest">
		<wsdl:part name="GetContextualKeywordsRequest" element="ns:GetContextualKeywordsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetCrossPromotionsResponse">
		<wsdl:part name="GetCrossPromotionsResponse" element="ns:GetCrossPromotionsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetCrossPromotionsRequest">
		<wsdl:part name="GetCrossPromotionsRequest" element="ns:GetCrossPromotionsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetDescriptionTemplatesResponse">
		<wsdl:part name="GetDescriptionTemplatesResponse" element="ns:GetDescriptionTemplatesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetDescriptionTemplatesRequest">
		<wsdl:part name="GetDescriptionTemplatesRequest" element="ns:GetDescriptionTemplatesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetDisputeResponse">
		<wsdl:part name="GetDisputeResponse" element="ns:GetDisputeResponse"/>
	</wsdl:message>
	<wsdl:message name="GetDisputeRequest">
		<wsdl:part name="GetDisputeRequest" element="ns:GetDisputeRequest"/>
	</wsdl:message>
	<wsdl:message name="GetFeedbackResponse">
		<wsdl:part name="GetFeedbackResponse" element="ns:GetFeedbackResponse"/>
	</wsdl:message>
	<wsdl:message name="GetFeedbackRequest">
		<wsdl:part name="GetFeedbackRequest" element="ns:GetFeedbackRequest"/>
	</wsdl:message>
	<wsdl:message name="GetFinanceOffersResponse">
		<wsdl:part name="GetFinanceOffersResponse" element="ns:GetFinanceOffersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetFinanceOffersRequest">
		<wsdl:part name="GetFinanceOffersRequest" element="ns:GetFinanceOffersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetHighBiddersResponse">
		<wsdl:part name="GetHighBiddersResponse" element="ns:GetHighBiddersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetHighBiddersRequest">
		<wsdl:part name="GetHighBiddersRequest" element="ns:GetHighBiddersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetItemResponse">
		<wsdl:part name="GetItemResponse" element="ns:GetItemResponse"/>
	</wsdl:message>
	<wsdl:message name="GetItemRequest">
		<wsdl:part name="GetItemRequest" element="ns:GetItemRequest"/>
	</wsdl:message>
	<wsdl:message name="GetItemRecommendationsResponse">
		<wsdl:part name="GetItemRecommendationsResponse" element="ns:GetItemRecommendationsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetItemRecommendationsRequest">
		<wsdl:part name="GetItemRecommendationsRequest" element="ns:GetItemRecommendationsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetItemShippingResponse">
		<wsdl:part name="GetItemShippingResponse" element="ns:GetItemShippingResponse"/>
	</wsdl:message>
	<wsdl:message name="GetItemShippingRequest">
		<wsdl:part name="GetItemShippingRequest" element="ns:GetItemShippingRequest"/>
	</wsdl:message>
	<wsdl:message name="GetItemTransactionsResponse">
		<wsdl:part name="GetItemTransactionsResponse" element="ns:GetItemTransactionsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetItemTransactionsRequest">
		<wsdl:part name="GetItemTransactionsRequest" element="ns:GetItemTransactionsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetItemsAwaitingFeedbackResponse">
		<wsdl:part name="GetItemsAwaitingFeedbackResponse" element="ns:GetItemsAwaitingFeedbackResponse"/>
	</wsdl:message>
	<wsdl:message name="GetItemsAwaitingFeedbackRequest">
		<wsdl:part name="GetItemsAwaitingFeedbackRequest" element="ns:GetItemsAwaitingFeedbackRequest"/>
	</wsdl:message>
	<wsdl:message name="GetLiveAuctionBiddersResponse">
		<wsdl:part name="GetLiveAuctionBiddersResponse" element="ns:GetLiveAuctionBiddersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetLiveAuctionBiddersRequest">
		<wsdl:part name="GetLiveAuctionBiddersRequest" element="ns:GetLiveAuctionBiddersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetLiveAuctionCatalogDetailsResponse">
		<wsdl:part name="GetLiveAuctionCatalogDetailsResponse" element="ns:GetLiveAuctionCatalogDetailsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetLiveAuctionCatalogDetailsRequest">
		<wsdl:part name="GetLiveAuctionCatalogDetailsRequest" element="ns:GetLiveAuctionCatalogDetailsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetMemberMessagesResponse">
		<wsdl:part name="GetMemberMessagesResponse" element="ns:GetMemberMessagesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetMemberMessagesRequest">
		<wsdl:part name="GetMemberMessagesRequest" element="ns:GetMemberMessagesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetMyMessagesResponse">
		<wsdl:part name="GetMyMessagesResponse" element="ns:GetMyMessagesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetMyMessagesRequest">
		<wsdl:part name="GetMyMessagesRequest" element="ns:GetMyMessagesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBayResponse">
		<wsdl:part name="GetMyeBayResponse" element="ns:GetMyeBayResponse"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBayRequest">
		<wsdl:part name="GetMyeBayRequest" element="ns:GetMyeBayRequest"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBayBuyingResponse">
		<wsdl:part name="GetMyeBayBuyingResponse" element="ns:GetMyeBayBuyingResponse"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBayBuyingRequest">
		<wsdl:part name="GetMyeBayBuyingRequest" element="ns:GetMyeBayBuyingRequest"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBayRemindersResponse">
		<wsdl:part name="GetMyeBayRemindersResponse" element="ns:GetMyeBayRemindersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBayRemindersRequest">
		<wsdl:part name="GetMyeBayRemindersRequest" element="ns:GetMyeBayRemindersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBaySellingResponse">
		<wsdl:part name="GetMyeBaySellingResponse" element="ns:GetMyeBaySellingResponse"/>
	</wsdl:message>
	<wsdl:message name="GetMyeBaySellingRequest">
		<wsdl:part name="GetMyeBaySellingRequest" element="ns:GetMyeBaySellingRequest"/>
	</wsdl:message>
	<wsdl:message name="GetNotificationPreferencesResponse">
		<wsdl:part name="GetNotificationPreferencesResponse" element="ns:GetNotificationPreferencesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetNotificationPreferencesRequest">
		<wsdl:part name="GetNotificationPreferencesRequest" element="ns:GetNotificationPreferencesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetNotificationsUsageResponse">
		<wsdl:part name="GetNotificationsUsageResponse" element="ns:GetNotificationsUsageResponse"/>
	</wsdl:message>
	<wsdl:message name="GetNotificationsUsageRequest">
		<wsdl:part name="GetNotificationsUsageRequest" element="ns:GetNotificationsUsageRequest"/>
	</wsdl:message>
	<wsdl:message name="GetOrderTransactionsResponse">
		<wsdl:part name="GetOrderTransactionsResponse" element="ns:GetOrderTransactionsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetOrderTransactionsRequest">
		<wsdl:part name="GetOrderTransactionsRequest" element="ns:GetOrderTransactionsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetOrdersResponse">
		<wsdl:part name="GetOrdersResponse" element="ns:GetOrdersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetOrdersRequest">
		<wsdl:part name="GetOrdersRequest" element="ns:GetOrdersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetPictureManagerDetailsResponse">
		<wsdl:part name="GetPictureManagerDetailsResponse" element="ns:GetPictureManagerDetailsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetPictureManagerDetailsRequest">
		<wsdl:part name="GetPictureManagerDetailsRequest" element="ns:GetPictureManagerDetailsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetPictureManagerOptionsResponse">
		<wsdl:part name="GetPictureManagerOptionsResponse" element="ns:GetPictureManagerOptionsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetPictureManagerOptionsRequest">
		<wsdl:part name="GetPictureManagerOptionsRequest" element="ns:GetPictureManagerOptionsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetPopularKeywordsResponse">
		<wsdl:part name="GetPopularKeywordsResponse" element="ns:GetPopularKeywordsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetPopularKeywordsRequest">
		<wsdl:part name="GetPopularKeywordsRequest" element="ns:GetPopularKeywordsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetProductFamilyMembersResponse">
		<wsdl:part name="GetProductFamilyMembersResponse" element="ns:GetProductFamilyMembersResponse"/>
	</wsdl:message>
	<wsdl:message name="GetProductFamilyMembersRequest">
		<wsdl:part name="GetProductFamilyMembersRequest" element="ns:GetProductFamilyMembersRequest"/>
	</wsdl:message>
	<wsdl:message name="GetProductFinderResponse">
		<wsdl:part name="GetProductFinderResponse" element="ns:GetProductFinderResponse"/>
	</wsdl:message>
	<wsdl:message name="GetProductFinderRequest">
		<wsdl:part name="GetProductFinderRequest" element="ns:GetProductFinderRequest"/>
	</wsdl:message>
	<wsdl:message name="GetProductFinderXSLResponse">
		<wsdl:part name="GetProductFinderXSLResponse" element="ns:GetProductFinderXSLResponse"/>
	</wsdl:message>
	<wsdl:message name="GetProductFinderXSLRequest">
		<wsdl:part name="GetProductFinderXSLRequest" element="ns:GetProductFinderXSLRequest"/>
	</wsdl:message>
	<wsdl:message name="GetProductSearchPageResponse">
		<wsdl:part name="GetProductSearchPageResponse" element="ns:GetProductSearchPageResponse"/>
	</wsdl:message>
	<wsdl:message name="GetProductSearchPageRequest">
		<wsdl:part name="GetProductSearchPageRequest" element="ns:GetProductSearchPageRequest"/>
	</wsdl:message>
	<wsdl:message name="GetProductSearchResultsResponse">
		<wsdl:part name="GetProductSearchResultsResponse" element="ns:GetProductSearchResultsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetProductSearchResultsRequest">
		<wsdl:part name="GetProductSearchResultsRequest" element="ns:GetProductSearchResultsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetProductSellingPagesResponse">
		<wsdl:part name="GetProductSellingPagesResponse" element="ns:GetProductSellingPagesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetProductSellingPagesRequest">
		<wsdl:part name="GetProductSellingPagesRequest" element="ns:GetProductSellingPagesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetPromotionRulesResponse">
		<wsdl:part name="GetPromotionRulesResponse" element="ns:GetPromotionRulesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetPromotionRulesRequest">
		<wsdl:part name="GetPromotionRulesRequest" element="ns:GetPromotionRulesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetRecommendationsResponse">
		<wsdl:part name="GetRecommendationsResponse" element="ns:GetRecommendationsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetRecommendationsRequest">
		<wsdl:part name="GetRecommendationsRequest" element="ns:GetRecommendationsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetReturnURLResponse">
		<wsdl:part name="GetReturnURLResponse" element="ns:GetReturnURLResponse"/>
	</wsdl:message>
	<wsdl:message name="GetReturnURLRequest">
		<wsdl:part name="GetReturnURLRequest" element="ns:GetReturnURLRequest"/>
	</wsdl:message>
	<wsdl:message name="GetRuNameResponse">
		<wsdl:part name="GetRuNameResponse" element="ns:GetRuNameResponse"/>
	</wsdl:message>
	<wsdl:message name="GetRuNameRequest">
		<wsdl:part name="GetRuNameRequest" element="ns:GetRuNameRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSearchResultsResponse">
		<wsdl:part name="GetSearchResultsResponse" element="ns:GetSearchResultsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSearchResultsRequest">
		<wsdl:part name="GetSearchResultsRequest" element="ns:GetSearchResultsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSearchResultsExpressResponse">
		<wsdl:part name="GetSearchResultsExpressResponse" element="ns:GetSearchResultsExpressResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSearchResultsExpressRequest">
		<wsdl:part name="GetSearchResultsExpressRequest" element="ns:GetSearchResultsExpressRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSellerEventsResponse">
		<wsdl:part name="GetSellerEventsResponse" element="ns:GetSellerEventsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSellerEventsRequest">
		<wsdl:part name="GetSellerEventsRequest" element="ns:GetSellerEventsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSellerListResponse">
		<wsdl:part name="GetSellerListResponse" element="ns:GetSellerListResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSellerListRequest">
		<wsdl:part name="GetSellerListRequest" element="ns:GetSellerListRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSellerPaymentsResponse">
		<wsdl:part name="GetSellerPaymentsResponse" element="ns:GetSellerPaymentsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSellerPaymentsRequest">
		<wsdl:part name="GetSellerPaymentsRequest" element="ns:GetSellerPaymentsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSellerTransactionsResponse">
		<wsdl:part name="GetSellerTransactionsResponse" element="ns:GetSellerTransactionsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSellerTransactionsRequest">
		<wsdl:part name="GetSellerTransactionsRequest" element="ns:GetSellerTransactionsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetStoreResponse">
		<wsdl:part name="GetStoreResponse" element="ns:GetStoreResponse"/>
	</wsdl:message>
	<wsdl:message name="GetStoreRequest">
		<wsdl:part name="GetStoreRequest" element="ns:GetStoreRequest"/>
	</wsdl:message>
	<wsdl:message name="GetStoreCategoryUpdateStatusResponse">
		<wsdl:part name="GetStoreCategoryUpdateStatusResponse" element="ns:GetStoreCategoryUpdateStatusResponse"/>
	</wsdl:message>
	<wsdl:message name="GetStoreCategoryUpdateStatusRequest">
		<wsdl:part name="GetStoreCategoryUpdateStatusRequest" element="ns:GetStoreCategoryUpdateStatusRequest"/>
	</wsdl:message>
	<wsdl:message name="GetStoreCustomPageResponse">
		<wsdl:part name="GetStoreCustomPageResponse" element="ns:GetStoreCustomPageResponse"/>
	</wsdl:message>
	<wsdl:message name="GetStoreCustomPageRequest">
		<wsdl:part name="GetStoreCustomPageRequest" element="ns:GetStoreCustomPageRequest"/>
	</wsdl:message>
	<wsdl:message name="GetStoreOptionsResponse">
		<wsdl:part name="GetStoreOptionsResponse" element="ns:GetStoreOptionsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetStoreOptionsRequest">
		<wsdl:part name="GetStoreOptionsRequest" element="ns:GetStoreOptionsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetStorePreferencesResponse">
		<wsdl:part name="GetStorePreferencesResponse" element="ns:GetStorePreferencesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetStorePreferencesRequest">
		<wsdl:part name="GetStorePreferencesRequest" element="ns:GetStorePreferencesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetSuggestedCategoriesResponse">
		<wsdl:part name="GetSuggestedCategoriesResponse" element="ns:GetSuggestedCategoriesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetSuggestedCategoriesRequest">
		<wsdl:part name="GetSuggestedCategoriesRequest" element="ns:GetSuggestedCategoriesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetTaxTableResponse">
		<wsdl:part name="GetTaxTableResponse" element="ns:GetTaxTableResponse"/>
	</wsdl:message>
	<wsdl:message name="GetTaxTableRequest">
		<wsdl:part name="GetTaxTableRequest" element="ns:GetTaxTableRequest"/>
	</wsdl:message>
	<wsdl:message name="GetUserResponse">
		<wsdl:part name="GetUserResponse" element="ns:GetUserResponse"/>
	</wsdl:message>
	<wsdl:message name="GetUserRequest">
		<wsdl:part name="GetUserRequest" element="ns:GetUserRequest"/>
	</wsdl:message>
	<wsdl:message name="GetUserContactDetailsResponse">
		<wsdl:part name="GetUserContactDetailsResponse" element="ns:GetUserContactDetailsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetUserContactDetailsRequest">
		<wsdl:part name="GetUserContactDetailsRequest" element="ns:GetUserContactDetailsRequest"/>
	</wsdl:message>
	<wsdl:message name="GetUserDisputesResponse">
		<wsdl:part name="GetUserDisputesResponse" element="ns:GetUserDisputesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetUserDisputesRequest">
		<wsdl:part name="GetUserDisputesRequest" element="ns:GetUserDisputesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetUserPreferencesResponse">
		<wsdl:part name="GetUserPreferencesResponse" element="ns:GetUserPreferencesResponse"/>
	</wsdl:message>
	<wsdl:message name="GetUserPreferencesRequest">
		<wsdl:part name="GetUserPreferencesRequest" element="ns:GetUserPreferencesRequest"/>
	</wsdl:message>
	<wsdl:message name="GetWantItNowPostResponse">
		<wsdl:part name="GetWantItNowPostResponse" element="ns:GetWantItNowPostResponse"/>
	</wsdl:message>
	<wsdl:message name="GetWantItNowPostRequest">
		<wsdl:part name="GetWantItNowPostRequest" element="ns:GetWantItNowPostRequest"/>
	</wsdl:message>
	<wsdl:message name="GetWantItNowSearchResultsResponse">
		<wsdl:part name="GetWantItNowSearchResultsResponse" element="ns:GetWantItNowSearchResultsResponse"/>
	</wsdl:message>
	<wsdl:message name="GetWantItNowSearchResultsRequest">
		<wsdl:part name="GetWantItNowSearchResultsRequest" element="ns:GetWantItNowSearchResultsRequest"/>
	</wsdl:message>
	<wsdl:message name="GeteBayDetailsResponse">
		<wsdl:part name="GeteBayDetailsResponse" element="ns:GeteBayDetailsResponse"/>
	</wsdl:message>
	<wsdl:message name="GeteBayDetailsRequest">
		<wsdl:part name="GeteBayDetailsRequest" element="ns:GeteBayDetailsRequest"/>
	</wsdl:message>
	<wsdl:message name="GeteBayOfficialTimeResponse">
		<wsdl:part name="GeteBayOfficialTimeResponse" element="ns:GeteBayOfficialTimeResponse"/>
	</wsdl:message>
	<wsdl:message name="GeteBayOfficialTimeRequest">
		<wsdl:part name="GeteBayOfficialTimeRequest" element="ns:GeteBayOfficialTimeRequest"/>
	</wsdl:message>
	<wsdl:message name="IssueRefundResponse">
		<wsdl:part name="IssueRefundResponse" element="ns:IssueRefundResponse"/>
	</wsdl:message>
	<wsdl:message name="IssueRefundRequest">
		<wsdl:part name="IssueRefundRequest" element="ns:IssueRefundRequest"/>
	</wsdl:message>
	<wsdl:message name="LeaveFeedbackResponse">
		<wsdl:part name="LeaveFeedbackResponse" element="ns:LeaveFeedbackResponse"/>
	</wsdl:message>
	<wsdl:message name="LeaveFeedbackRequest">
		<wsdl:part name="LeaveFeedbackRequest" element="ns:LeaveFeedbackRequest"/>
	</wsdl:message>
	<wsdl:message name="PlaceOfferResponse">
		<wsdl:part name="PlaceOfferResponse" element="ns:PlaceOfferResponse"/>
	</wsdl:message>
	<wsdl:message name="PlaceOfferRequest">
		<wsdl:part name="PlaceOfferRequest" element="ns:PlaceOfferRequest"/>
	</wsdl:message>
	<wsdl:message name="RelistItemResponse">
		<wsdl:part name="RelistItemResponse" element="ns:RelistItemResponse"/>
	</wsdl:message>
	<wsdl:message name="RelistItemRequest">
		<wsdl:part name="RelistItemRequest" element="ns:RelistItemRequest"/>
	</wsdl:message>
	<wsdl:message name="RemoveFromWatchListResponse">
		<wsdl:part name="RemoveFromWatchListResponse" element="ns:RemoveFromWatchListResponse"/>
	</wsdl:message>
	<wsdl:message name="RemoveFromWatchListRequest">
		<wsdl:part name="RemoveFromWatchListRequest" element="ns:RemoveFromWatchListRequest"/>
	</wsdl:message>
	<wsdl:message name="RespondToBestOfferResponse">
		<wsdl:part name="RespondToBestOfferResponse" element="ns:RespondToBestOfferResponse"/>
	</wsdl:message>
	<wsdl:message name="RespondToBestOfferRequest">
		<wsdl:part name="RespondToBestOfferRequest" element="ns:RespondToBestOfferRequest"/>
	</wsdl:message>
	<wsdl:message name="RespondToFeedbackResponse">
		<wsdl:part name="RespondToFeedbackResponse" element="ns:RespondToFeedbackResponse"/>
	</wsdl:message>
	<wsdl:message name="RespondToFeedbackRequest">
		<wsdl:part name="RespondToFeedbackRequest" element="ns:RespondToFeedbackRequest"/>
	</wsdl:message>
	<wsdl:message name="RespondToWantItNowPostResponse">
		<wsdl:part name="RespondToWantItNowPostResponse" element="ns:RespondToWantItNowPostResponse"/>
	</wsdl:message>
	<wsdl:message name="RespondToWantItNowPostRequest">
		<wsdl:part name="RespondToWantItNowPostRequest" element="ns:RespondToWantItNowPostRequest"/>
	</wsdl:message>
	<wsdl:message name="ReviseCheckoutStatusResponse">
		<wsdl:part name="ReviseCheckoutStatusResponse" element="ns:ReviseCheckoutStatusResponse"/>
	</wsdl:message>
	<wsdl:message name="ReviseCheckoutStatusRequest">
		<wsdl:part name="ReviseCheckoutStatusRequest" element="ns:ReviseCheckoutStatusRequest"/>
	</wsdl:message>
	<wsdl:message name="ReviseItemResponse">
		<wsdl:part name="ReviseItemResponse" element="ns:ReviseItemResponse"/>
	</wsdl:message>
	<wsdl:message name="ReviseItemRequest">
		<wsdl:part name="ReviseItemRequest" element="ns:ReviseItemRequest"/>
	</wsdl:message>
	<wsdl:message name="ReviseLiveAuctionItemResponse">
		<wsdl:part name="ReviseLiveAuctionItemResponse" element="ns:ReviseLiveAuctionItemResponse"/>
	</wsdl:message>
	<wsdl:message name="ReviseLiveAuctionItemRequest">
		<wsdl:part name="ReviseLiveAuctionItemRequest" element="ns:ReviseLiveAuctionItemRequest"/>
	</wsdl:message>
	<wsdl:message name="ReviseMyMessagesResponse">
		<wsdl:part name="ReviseMyMessagesResponse" element="ns:ReviseMyMessagesResponse"/>
	</wsdl:message>
	<wsdl:message name="ReviseMyMessagesRequest">
		<wsdl:part name="ReviseMyMessagesRequest" element="ns:ReviseMyMessagesRequest"/>
	</wsdl:message>
	<wsdl:message name="ReviseMyMessagesFoldersResponse">
		<wsdl:part name="ReviseMyMessagesFoldersResponse" element="ns:ReviseMyMessagesFoldersResponse"/>
	</wsdl:message>
	<wsdl:message name="ReviseMyMessagesFoldersRequest">
		<wsdl:part name="ReviseMyMessagesFoldersRequest" element="ns:ReviseMyMessagesFoldersRequest"/>
	</wsdl:message>
	<wsdl:message name="SellerReverseDisputeResponse">
		<wsdl:part name="SellerReverseDisputeResponse" element="ns:SellerReverseDisputeResponse"/>
	</wsdl:message>
	<wsdl:message name="SellerReverseDisputeRequest">
		<wsdl:part name="SellerReverseDisputeRequest" element="ns:SellerReverseDisputeRequest"/>
	</wsdl:message>
	<wsdl:message name="SendInvoiceResponse">
		<wsdl:part name="SendInvoiceResponse" element="ns:SendInvoiceResponse"/>
	</wsdl:message>
	<wsdl:message name="SendInvoiceRequest">
		<wsdl:part name="SendInvoiceRequest" element="ns:SendInvoiceRequest"/>
	</wsdl:message>
	<wsdl:message name="SetNotificationPreferencesResponse">
		<wsdl:part name="SetNotificationPreferencesResponse" element="ns:SetNotificationPreferencesResponse"/>
	</wsdl:message>
	<wsdl:message name="SetNotificationPreferencesRequest">
		<wsdl:part name="SetNotificationPreferencesRequest" element="ns:SetNotificationPreferencesRequest"/>
	</wsdl:message>
	<wsdl:message name="SetPictureManagerDetailsResponse">
		<wsdl:part name="SetPictureManagerDetailsResponse" element="ns:SetPictureManagerDetailsResponse"/>
	</wsdl:message>
	<wsdl:message name="SetPictureManagerDetailsRequest">
		<wsdl:part name="SetPictureManagerDetailsRequest" element="ns:SetPictureManagerDetailsRequest"/>
	</wsdl:message>
	<wsdl:message name="SetPromotionRulesResponse">
		<wsdl:part name="SetPromotionRulesResponse" element="ns:SetPromotionRulesResponse"/>
	</wsdl:message>
	<wsdl:message name="SetPromotionRulesRequest">
		<wsdl:part name="SetPromotionRulesRequest" element="ns:SetPromotionRulesRequest"/>
	</wsdl:message>
	<wsdl:message name="SetReturnURLResponse">
		<wsdl:part name="SetReturnURLResponse" element="ns:SetReturnURLResponse"/>
	</wsdl:message>
	<wsdl:message name="SetReturnURLRequest">
		<wsdl:part name="SetReturnURLRequest" element="ns:SetReturnURLRequest"/>
	</wsdl:message>
	<wsdl:message name="SetStoreResponse">
		<wsdl:part name="SetStoreResponse" element="ns:SetStoreResponse"/>
	</wsdl:message>
	<wsdl:message name="SetStoreRequest">
		<wsdl:part name="SetStoreRequest" element="ns:SetStoreRequest"/>
	</wsdl:message>
	<wsdl:message name="SetStoreCategoriesResponse">
		<wsdl:part name="SetStoreCategoriesResponse" element="ns:SetStoreCategoriesResponse"/>
	</wsdl:message>
	<wsdl:message name="SetStoreCategoriesRequest">
		<wsdl:part name="SetStoreCategoriesRequest" element="ns:SetStoreCategoriesRequest"/>
	</wsdl:message>
	<wsdl:message name="SetStoreCustomPageResponse">
		<wsdl:part name="SetStoreCustomPageResponse" element="ns:SetStoreCustomPageResponse"/>
	</wsdl:message>
	<wsdl:message name="SetStoreCustomPageRequest">
		<wsdl:part name="SetStoreCustomPageRequest" element="ns:SetStoreCustomPageRequest"/>
	</wsdl:message>
	<wsdl:message name="SetStorePreferencesResponse">
		<wsdl:part name="SetStorePreferencesResponse" element="ns:SetStorePreferencesResponse"/>
	</wsdl:message>
	<wsdl:message name="SetStorePreferencesRequest">
		<wsdl:part name="SetStorePreferencesRequest" element="ns:SetStorePreferencesRequest"/>
	</wsdl:message>
	<wsdl:message name="SetTaxTableResponse">
		<wsdl:part name="SetTaxTableResponse" element="ns:SetTaxTableResponse"/>
	</wsdl:message>
	<wsdl:message name="SetTaxTableRequest">
		<wsdl:part name="SetTaxTableRequest" element="ns:SetTaxTableRequest"/>
	</wsdl:message>
	<wsdl:message name="SetUserNotesResponse">
		<wsdl:part name="SetUserNotesResponse" element="ns:SetUserNotesResponse"/>
	</wsdl:message>
	<wsdl:message name="SetUserNotesRequest">
		<wsdl:part name="SetUserNotesRequest" element="ns:SetUserNotesRequest"/>
	</wsdl:message>
	<wsdl:message name="SetUserPreferencesResponse">
		<wsdl:part name="SetUserPreferencesResponse" element="ns:SetUserPreferencesResponse"/>
	</wsdl:message>
	<wsdl:message name="SetUserPreferencesRequest">
		<wsdl:part name="SetUserPreferencesRequest" element="ns:SetUserPreferencesRequest"/>
	</wsdl:message>
	<wsdl:message name="ValidateTestUserRegistrationResponse">
		<wsdl:part name="ValidateTestUserRegistrationResponse" element="ns:ValidateTestUserRegistrationResponse"/>
	</wsdl:message>
	<wsdl:message name="ValidateTestUserRegistrationRequest">
		<wsdl:part name="ValidateTestUserRegistrationRequest" element="ns:ValidateTestUserRegistrationRequest"/>
	</wsdl:message>
	<wsdl:message name="VerifyAddItemResponse">
		<wsdl:part name="VerifyAddItemResponse" element="ns:VerifyAddItemResponse"/>
	</wsdl:message>
	<wsdl:message name="VerifyAddItemRequest">
		<wsdl:part name="VerifyAddItemRequest" element="ns:VerifyAddItemRequest"/>
	</wsdl:message>
	<wsdl:message name="VerifyAddSecondChanceItemResponse">
		<wsdl:part name="VerifyAddSecondChanceItemResponse" element="ns:VerifyAddSecondChanceItemResponse"/>
	</wsdl:message>
	<wsdl:message name="VerifyAddSecondChanceItemRequest">
		<wsdl:part name="VerifyAddSecondChanceItemRequest" element="ns:VerifyAddSecondChanceItemRequest"/>
	</wsdl:message>
	<wsdl:portType name="eBayAPIInterface">
			
		<wsdl:operation name="AddDispute">
			<wsdl:input message="ns:AddDisputeRequest"/>
			<wsdl:output message="ns:AddDisputeResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddDisputeResponse">
			<wsdl:input message="ns:AddDisputeResponseRequest"/>
			<wsdl:output message="ns:AddDisputeResponseResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddItem">
			<wsdl:input message="ns:AddItemRequest"/>
			<wsdl:output message="ns:AddItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddLiveAuctionItem">
			<wsdl:input message="ns:AddLiveAuctionItemRequest"/>
			<wsdl:output message="ns:AddLiveAuctionItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessage">
			<wsdl:input message="ns:AddMemberMessageRequest"/>
			<wsdl:output message="ns:AddMemberMessageResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessageAAQToPartner">
			<wsdl:input message="ns:AddMemberMessageAAQToPartnerRequest"/>
			<wsdl:output message="ns:AddMemberMessageAAQToPartnerResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessageRTQ">
			<wsdl:input message="ns:AddMemberMessageRTQRequest"/>
			<wsdl:output message="ns:AddMemberMessageRTQResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessagesAAQToBidder">
			<wsdl:input message="ns:AddMemberMessagesAAQToBidderRequest"/>
			<wsdl:output message="ns:AddMemberMessagesAAQToBidderResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddOrder">
			<wsdl:input message="ns:AddOrderRequest"/>
			<wsdl:output message="ns:AddOrderResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddSecondChanceItem">
			<wsdl:input message="ns:AddSecondChanceItemRequest"/>
			<wsdl:output message="ns:AddSecondChanceItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddToItemDescription">
			<wsdl:input message="ns:AddToItemDescriptionRequest"/>
			<wsdl:output message="ns:AddToItemDescriptionResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddToWatchList">
			<wsdl:input message="ns:AddToWatchListRequest"/>
			<wsdl:output message="ns:AddToWatchListResponse"/>
		</wsdl:operation>
		<wsdl:operation name="AddTransactionConfirmationItem">
			<wsdl:input message="ns:AddTransactionConfirmationItemRequest"/>
			<wsdl:output message="ns:AddTransactionConfirmationItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ApproveLiveAuctionBidders">
			<wsdl:input message="ns:ApproveLiveAuctionBiddersRequest"/>
			<wsdl:output message="ns:ApproveLiveAuctionBiddersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="CompleteSale">
			<wsdl:input message="ns:CompleteSaleRequest"/>
			<wsdl:output message="ns:CompleteSaleResponse"/>
		</wsdl:operation>
		<wsdl:operation name="DeleteMyMessages">
			<wsdl:input message="ns:DeleteMyMessagesRequest"/>
			<wsdl:output message="ns:DeleteMyMessagesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="EndItem">
			<wsdl:input message="ns:EndItemRequest"/>
			<wsdl:output message="ns:EndItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="FetchToken">
			<wsdl:input message="ns:FetchTokenRequest"/>
			<wsdl:output message="ns:FetchTokenResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetAccount">
			<wsdl:input message="ns:GetAccountRequest"/>
			<wsdl:output message="ns:GetAccountResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetAdFormatLeads">
			<wsdl:input message="ns:GetAdFormatLeadsRequest"/>
			<wsdl:output message="ns:GetAdFormatLeadsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetAllBidders">
			<wsdl:input message="ns:GetAllBiddersRequest"/>
			<wsdl:output message="ns:GetAllBiddersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetApiAccessRules">
			<wsdl:input message="ns:GetApiAccessRulesRequest"/>
			<wsdl:output message="ns:GetApiAccessRulesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetAttributesCS">
			<wsdl:input message="ns:GetAttributesCSRequest"/>
			<wsdl:output message="ns:GetAttributesCSResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetAttributesXSL">
			<wsdl:input message="ns:GetAttributesXSLRequest"/>
			<wsdl:output message="ns:GetAttributesXSLResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetBestOffers">
			<wsdl:input message="ns:GetBestOffersRequest"/>
			<wsdl:output message="ns:GetBestOffersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetBidderList">
			<wsdl:input message="ns:GetBidderListRequest"/>
			<wsdl:output message="ns:GetBidderListResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCategories">
			<wsdl:input message="ns:GetCategoriesRequest"/>
			<wsdl:output message="ns:GetCategoriesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCategory2CS">
			<wsdl:input message="ns:GetCategory2CSRequest"/>
			<wsdl:output message="ns:GetCategory2CSResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCategory2FinanceOffer">
			<wsdl:input message="ns:GetCategory2FinanceOfferRequest"/>
			<wsdl:output message="ns:GetCategory2FinanceOfferResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCategoryFeatures">
			<wsdl:input message="ns:GetCategoryFeaturesRequest"/>
			<wsdl:output message="ns:GetCategoryFeaturesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCategoryListings">
			<wsdl:input message="ns:GetCategoryListingsRequest"/>
			<wsdl:output message="ns:GetCategoryListingsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCategoryMappings">
			<wsdl:input message="ns:GetCategoryMappingsRequest"/>
			<wsdl:output message="ns:GetCategoryMappingsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCharities">
			<wsdl:input message="ns:GetCharitiesRequest"/>
			<wsdl:output message="ns:GetCharitiesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetContextualKeywords">
			<wsdl:input message="ns:GetContextualKeywordsRequest"/>
			<wsdl:output message="ns:GetContextualKeywordsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetCrossPromotions">
			<wsdl:input message="ns:GetCrossPromotionsRequest"/>
			<wsdl:output message="ns:GetCrossPromotionsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetDescriptionTemplates">
			<wsdl:input message="ns:GetDescriptionTemplatesRequest"/>
			<wsdl:output message="ns:GetDescriptionTemplatesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetDispute">
			<wsdl:input message="ns:GetDisputeRequest"/>
			<wsdl:output message="ns:GetDisputeResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetFeedback">
			<wsdl:input message="ns:GetFeedbackRequest"/>
			<wsdl:output message="ns:GetFeedbackResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetFinanceOffers">
			<wsdl:input message="ns:GetFinanceOffersRequest"/>
			<wsdl:output message="ns:GetFinanceOffersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetHighBidders">
			<wsdl:input message="ns:GetHighBiddersRequest"/>
			<wsdl:output message="ns:GetHighBiddersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetItem">
			<wsdl:input message="ns:GetItemRequest"/>
			<wsdl:output message="ns:GetItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetItemRecommendations">
			<wsdl:input message="ns:GetItemRecommendationsRequest"/>
			<wsdl:output message="ns:GetItemRecommendationsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetItemShipping">
			<wsdl:input message="ns:GetItemShippingRequest"/>
			<wsdl:output message="ns:GetItemShippingResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetItemTransactions">
			<wsdl:input message="ns:GetItemTransactionsRequest"/>
			<wsdl:output message="ns:GetItemTransactionsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetItemsAwaitingFeedback">
			<wsdl:input message="ns:GetItemsAwaitingFeedbackRequest"/>
			<wsdl:output message="ns:GetItemsAwaitingFeedbackResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetLiveAuctionBidders">
			<wsdl:input message="ns:GetLiveAuctionBiddersRequest"/>
			<wsdl:output message="ns:GetLiveAuctionBiddersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetLiveAuctionCatalogDetails">
			<wsdl:input message="ns:GetLiveAuctionCatalogDetailsRequest"/>
			<wsdl:output message="ns:GetLiveAuctionCatalogDetailsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetMemberMessages">
			<wsdl:input message="ns:GetMemberMessagesRequest"/>
			<wsdl:output message="ns:GetMemberMessagesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetMyMessages">
			<wsdl:input message="ns:GetMyMessagesRequest"/>
			<wsdl:output message="ns:GetMyMessagesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBay">
			<wsdl:input message="ns:GetMyeBayRequest"/>
			<wsdl:output message="ns:GetMyeBayResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBayBuying">
			<wsdl:input message="ns:GetMyeBayBuyingRequest"/>
			<wsdl:output message="ns:GetMyeBayBuyingResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBayReminders">
			<wsdl:input message="ns:GetMyeBayRemindersRequest"/>
			<wsdl:output message="ns:GetMyeBayRemindersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBaySelling">
			<wsdl:input message="ns:GetMyeBaySellingRequest"/>
			<wsdl:output message="ns:GetMyeBaySellingResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetNotificationPreferences">
			<wsdl:input message="ns:GetNotificationPreferencesRequest"/>
			<wsdl:output message="ns:GetNotificationPreferencesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetNotificationsUsage">
			<wsdl:input message="ns:GetNotificationsUsageRequest"/>
			<wsdl:output message="ns:GetNotificationsUsageResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetOrderTransactions">
			<wsdl:input message="ns:GetOrderTransactionsRequest"/>
			<wsdl:output message="ns:GetOrderTransactionsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetOrders">
			<wsdl:input message="ns:GetOrdersRequest"/>
			<wsdl:output message="ns:GetOrdersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetPictureManagerDetails">
			<wsdl:input message="ns:GetPictureManagerDetailsRequest"/>
			<wsdl:output message="ns:GetPictureManagerDetailsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetPictureManagerOptions">
			<wsdl:input message="ns:GetPictureManagerOptionsRequest"/>
			<wsdl:output message="ns:GetPictureManagerOptionsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetPopularKeywords">
			<wsdl:input message="ns:GetPopularKeywordsRequest"/>
			<wsdl:output message="ns:GetPopularKeywordsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetProductFamilyMembers">
			<wsdl:input message="ns:GetProductFamilyMembersRequest"/>
			<wsdl:output message="ns:GetProductFamilyMembersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetProductFinder">
			<wsdl:input message="ns:GetProductFinderRequest"/>
			<wsdl:output message="ns:GetProductFinderResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetProductFinderXSL">
			<wsdl:input message="ns:GetProductFinderXSLRequest"/>
			<wsdl:output message="ns:GetProductFinderXSLResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetProductSearchPage">
			<wsdl:input message="ns:GetProductSearchPageRequest"/>
			<wsdl:output message="ns:GetProductSearchPageResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetProductSearchResults">
			<wsdl:input message="ns:GetProductSearchResultsRequest"/>
			<wsdl:output message="ns:GetProductSearchResultsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetProductSellingPages">
			<wsdl:input message="ns:GetProductSellingPagesRequest"/>
			<wsdl:output message="ns:GetProductSellingPagesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetPromotionRules">
			<wsdl:input message="ns:GetPromotionRulesRequest"/>
			<wsdl:output message="ns:GetPromotionRulesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetRecommendations">
			<wsdl:input message="ns:GetRecommendationsRequest"/>
			<wsdl:output message="ns:GetRecommendationsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetReturnURL">
			<wsdl:input message="ns:GetReturnURLRequest"/>
			<wsdl:output message="ns:GetReturnURLResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetRuName">
			<wsdl:input message="ns:GetRuNameRequest"/>
			<wsdl:output message="ns:GetRuNameResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSearchResults">
			<wsdl:input message="ns:GetSearchResultsRequest"/>
			<wsdl:output message="ns:GetSearchResultsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSearchResultsExpress">
			<wsdl:input message="ns:GetSearchResultsExpressRequest"/>
			<wsdl:output message="ns:GetSearchResultsExpressResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSellerEvents">
			<wsdl:input message="ns:GetSellerEventsRequest"/>
			<wsdl:output message="ns:GetSellerEventsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSellerList">
			<wsdl:input message="ns:GetSellerListRequest"/>
			<wsdl:output message="ns:GetSellerListResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSellerPayments">
			<wsdl:input message="ns:GetSellerPaymentsRequest"/>
			<wsdl:output message="ns:GetSellerPaymentsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSellerTransactions">
			<wsdl:input message="ns:GetSellerTransactionsRequest"/>
			<wsdl:output message="ns:GetSellerTransactionsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetStore">
			<wsdl:input message="ns:GetStoreRequest"/>
			<wsdl:output message="ns:GetStoreResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetStoreCategoryUpdateStatus">
			<wsdl:input message="ns:GetStoreCategoryUpdateStatusRequest"/>
			<wsdl:output message="ns:GetStoreCategoryUpdateStatusResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetStoreCustomPage">
			<wsdl:input message="ns:GetStoreCustomPageRequest"/>
			<wsdl:output message="ns:GetStoreCustomPageResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetStoreOptions">
			<wsdl:input message="ns:GetStoreOptionsRequest"/>
			<wsdl:output message="ns:GetStoreOptionsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetStorePreferences">
			<wsdl:input message="ns:GetStorePreferencesRequest"/>
			<wsdl:output message="ns:GetStorePreferencesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetSuggestedCategories">
			<wsdl:input message="ns:GetSuggestedCategoriesRequest"/>
			<wsdl:output message="ns:GetSuggestedCategoriesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetTaxTable">
			<wsdl:input message="ns:GetTaxTableRequest"/>
			<wsdl:output message="ns:GetTaxTableResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetUser">
			<wsdl:input message="ns:GetUserRequest"/>
			<wsdl:output message="ns:GetUserResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetUserContactDetails">
			<wsdl:input message="ns:GetUserContactDetailsRequest"/>
			<wsdl:output message="ns:GetUserContactDetailsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetUserDisputes">
			<wsdl:input message="ns:GetUserDisputesRequest"/>
			<wsdl:output message="ns:GetUserDisputesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetUserPreferences">
			<wsdl:input message="ns:GetUserPreferencesRequest"/>
			<wsdl:output message="ns:GetUserPreferencesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetWantItNowPost">
			<wsdl:input message="ns:GetWantItNowPostRequest"/>
			<wsdl:output message="ns:GetWantItNowPostResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GetWantItNowSearchResults">
			<wsdl:input message="ns:GetWantItNowSearchResultsRequest"/>
			<wsdl:output message="ns:GetWantItNowSearchResultsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GeteBayDetails">
			<wsdl:input message="ns:GeteBayDetailsRequest"/>
			<wsdl:output message="ns:GeteBayDetailsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="GeteBayOfficialTime">
			<wsdl:input message="ns:GeteBayOfficialTimeRequest"/>
			<wsdl:output message="ns:GeteBayOfficialTimeResponse"/>
		</wsdl:operation>
		<wsdl:operation name="IssueRefund">
			<wsdl:input message="ns:IssueRefundRequest"/>
			<wsdl:output message="ns:IssueRefundResponse"/>
		</wsdl:operation>
		<wsdl:operation name="LeaveFeedback">
			<wsdl:input message="ns:LeaveFeedbackRequest"/>
			<wsdl:output message="ns:LeaveFeedbackResponse"/>
		</wsdl:operation>
		<wsdl:operation name="PlaceOffer">
			<wsdl:input message="ns:PlaceOfferRequest"/>
			<wsdl:output message="ns:PlaceOfferResponse"/>
		</wsdl:operation>
		<wsdl:operation name="RelistItem">
			<wsdl:input message="ns:RelistItemRequest"/>
			<wsdl:output message="ns:RelistItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="RemoveFromWatchList">
			<wsdl:input message="ns:RemoveFromWatchListRequest"/>
			<wsdl:output message="ns:RemoveFromWatchListResponse"/>
		</wsdl:operation>
		<wsdl:operation name="RespondToBestOffer">
			<wsdl:input message="ns:RespondToBestOfferRequest"/>
			<wsdl:output message="ns:RespondToBestOfferResponse"/>
		</wsdl:operation>
		<wsdl:operation name="RespondToFeedback">
			<wsdl:input message="ns:RespondToFeedbackRequest"/>
			<wsdl:output message="ns:RespondToFeedbackResponse"/>
		</wsdl:operation>
		<wsdl:operation name="RespondToWantItNowPost">
			<wsdl:input message="ns:RespondToWantItNowPostRequest"/>
			<wsdl:output message="ns:RespondToWantItNowPostResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ReviseCheckoutStatus">
			<wsdl:input message="ns:ReviseCheckoutStatusRequest"/>
			<wsdl:output message="ns:ReviseCheckoutStatusResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ReviseItem">
			<wsdl:input message="ns:ReviseItemRequest"/>
			<wsdl:output message="ns:ReviseItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ReviseLiveAuctionItem">
			<wsdl:input message="ns:ReviseLiveAuctionItemRequest"/>
			<wsdl:output message="ns:ReviseLiveAuctionItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ReviseMyMessages">
			<wsdl:input message="ns:ReviseMyMessagesRequest"/>
			<wsdl:output message="ns:ReviseMyMessagesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ReviseMyMessagesFolders">
			<wsdl:input message="ns:ReviseMyMessagesFoldersRequest"/>
			<wsdl:output message="ns:ReviseMyMessagesFoldersResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SellerReverseDispute">
			<wsdl:input message="ns:SellerReverseDisputeRequest"/>
			<wsdl:output message="ns:SellerReverseDisputeResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SendInvoice">
			<wsdl:input message="ns:SendInvoiceRequest"/>
			<wsdl:output message="ns:SendInvoiceResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetNotificationPreferences">
			<wsdl:input message="ns:SetNotificationPreferencesRequest"/>
			<wsdl:output message="ns:SetNotificationPreferencesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetPictureManagerDetails">
			<wsdl:input message="ns:SetPictureManagerDetailsRequest"/>
			<wsdl:output message="ns:SetPictureManagerDetailsResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetPromotionRules">
			<wsdl:input message="ns:SetPromotionRulesRequest"/>
			<wsdl:output message="ns:SetPromotionRulesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetReturnURL">
			<wsdl:input message="ns:SetReturnURLRequest"/>
			<wsdl:output message="ns:SetReturnURLResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetStore">
			<wsdl:input message="ns:SetStoreRequest"/>
			<wsdl:output message="ns:SetStoreResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetStoreCategories">
			<wsdl:input message="ns:SetStoreCategoriesRequest"/>
			<wsdl:output message="ns:SetStoreCategoriesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetStoreCustomPage">
			<wsdl:input message="ns:SetStoreCustomPageRequest"/>
			<wsdl:output message="ns:SetStoreCustomPageResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetStorePreferences">
			<wsdl:input message="ns:SetStorePreferencesRequest"/>
			<wsdl:output message="ns:SetStorePreferencesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetTaxTable">
			<wsdl:input message="ns:SetTaxTableRequest"/>
			<wsdl:output message="ns:SetTaxTableResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetUserNotes">
			<wsdl:input message="ns:SetUserNotesRequest"/>
			<wsdl:output message="ns:SetUserNotesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="SetUserPreferences">
			<wsdl:input message="ns:SetUserPreferencesRequest"/>
			<wsdl:output message="ns:SetUserPreferencesResponse"/>
		</wsdl:operation>
		<wsdl:operation name="ValidateTestUserRegistration">
			<wsdl:input message="ns:ValidateTestUserRegistrationRequest"/>
			<wsdl:output message="ns:ValidateTestUserRegistrationResponse"/>
		</wsdl:operation>
		<wsdl:operation name="VerifyAddItem">
			<wsdl:input message="ns:VerifyAddItemRequest"/>
			<wsdl:output message="ns:VerifyAddItemResponse"/>
		</wsdl:operation>
		<wsdl:operation name="VerifyAddSecondChanceItem">
			<wsdl:input message="ns:VerifyAddSecondChanceItemRequest"/>
			<wsdl:output message="ns:VerifyAddSecondChanceItemResponse"/>
		</wsdl:operation>
	</wsdl:portType>
	<wsdl:binding name="eBayAPISoapBinding" type="ns:eBayAPIInterface">	
	<wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
			
		<wsdl:operation name="AddDispute">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddDisputeResponse">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddLiveAuctionItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessage">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessageAAQToPartner">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessageRTQ">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddMemberMessagesAAQToBidder">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddOrder">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddSecondChanceItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddToItemDescription">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddToWatchList">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="AddTransactionConfirmationItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ApproveLiveAuctionBidders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="CompleteSale">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="DeleteMyMessages">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="EndItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="FetchToken">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetAccount">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetAdFormatLeads">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetAllBidders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetApiAccessRules">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetAttributesCS">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetAttributesXSL">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetBestOffers">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetBidderList">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCategories">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCategory2CS">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCategory2FinanceOffer">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCategoryFeatures">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCategoryListings">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCategoryMappings">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCharities">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetContextualKeywords">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetCrossPromotions">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetDescriptionTemplates">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetDispute">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetFeedback">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetFinanceOffers">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetHighBidders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetItemRecommendations">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetItemShipping">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetItemTransactions">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetItemsAwaitingFeedback">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetLiveAuctionBidders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetLiveAuctionCatalogDetails">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetMemberMessages">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetMyMessages">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBay">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBayBuying">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBayReminders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetMyeBaySelling">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetNotificationPreferences">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetNotificationsUsage">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetOrderTransactions">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetOrders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetPictureManagerDetails">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetPictureManagerOptions">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetPopularKeywords">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetProductFamilyMembers">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetProductFinder">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetProductFinderXSL">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetProductSearchPage">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetProductSearchResults">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetProductSellingPages">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetPromotionRules">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetRecommendations">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetReturnURL">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetRuName">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSearchResults">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSearchResultsExpress">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSellerEvents">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSellerList">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSellerPayments">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSellerTransactions">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetStore">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetStoreCategoryUpdateStatus">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetStoreCustomPage">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetStoreOptions">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetStorePreferences">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetSuggestedCategories">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetTaxTable">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetUser">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetUserContactDetails">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetUserDisputes">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetUserPreferences">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetWantItNowPost">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GetWantItNowSearchResults">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GeteBayDetails">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="GeteBayOfficialTime">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="IssueRefund">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="LeaveFeedback">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="PlaceOffer">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="RelistItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="RemoveFromWatchList">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="RespondToBestOffer">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="RespondToFeedback">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="RespondToWantItNowPost">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ReviseCheckoutStatus">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ReviseItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ReviseLiveAuctionItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ReviseMyMessages">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ReviseMyMessagesFolders">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SellerReverseDispute">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SendInvoice">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetNotificationPreferences">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetPictureManagerDetails">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetPromotionRules">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetReturnURL">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetStore">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetStoreCategories">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetStoreCustomPage">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetStorePreferences">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetTaxTable">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetUserNotes">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="SetUserPreferences">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="ValidateTestUserRegistration">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="VerifyAddItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="VerifyAddSecondChanceItem">
			<wsdlsoap:operation soapAction=""/>
			<wsdl:input>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:header use="literal" message="ns:RequesterCredentials" part="RequesterCredentials"/>
				<wsdlsoap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
	</wsdl:binding>
	<wsdl:service name="eBayAPIInterfaceService">
			<wsdl:documentation>Version 471</wsdl:documentation>
			<wsdl:port binding="ns:eBayAPISoapBinding" name="eBayAPI">
				<wsdlsoap:address location="https://api.ebay.com/wsapi"/>
			</wsdl:port>
	</wsdl:service>
</wsdl:definitions>
	