<?xml version="1.0" encoding="UTF-8"?>
<!--

    Copyright (c) 2002, 2018 Oracle and/or its affiliates. All rights reserved.

    This program and the accompanying materials are made available under the
    terms of the Eclipse Public License v. 2.0, which is available at
    http://www.eclipse.org/legal/epl-2.0.

    This Source Code may also be made available under the following Secondary
    Licenses when the conditions for such availability set forth in the
    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
    version 2 with the GNU Classpath Exception, which is available at
    https://www.gnu.org/software/classpath/license.html.

    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0

-->

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"  
	xmlns:log="http://www.ws-i.org/SampleApplications/SupplyChainManagement/2002-08/LoggingFacility.xsd"  
	targetNamespace="http://www.ws-i.org/SampleApplications/SupplyChainManagement/2002-08/LoggingFacility.xsd">

	<xs:element name="logEventRequestElement" type="log:logEventRequestType"/>
	<xs:complexType name="logEventRequestType">
		<xs:sequence>
			<xs:element name="DemoUserID" type="xs:string"/>
			<xs:element name="ServiceID" type="xs:string"/>
			<xs:element name="EventID" type="xs:string"/>
			<xs:element name="EventDescription" type="xs:string"/>
			<xs:any namespace="##other" minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
		</xs:sequence>
	</xs:complexType>

	<xs:element name="getEventsRequestElement" type="log:getEventsRequestType"/>
	<xs:complexType name="getEventsRequestType">
		<xs:sequence>
			<xs:element name="DemoUserID" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:element name="getEventsResponseElement" type="log:getEventsResponseType"/>
	<xs:complexType name="getEventsResponseType">
		<xs:sequence>
			<xs:element name="LogEntry" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="Timestamp" type="xs:dateTime"/>
						<xs:element name="ServiceID" type="xs:string"/>
						<xs:element name="EventID" type="xs:string"/>
						<xs:element name="EventDescription" type="xs:string"/>
						<xs:any namespace="##other" minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
					</xs:sequence>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>

	<xs:element name="getEventsFaultElement" type="log:getEventsFaultType"/>
	<xs:complexType name="getEventsFaultType">
		<xs:sequence>
			<xs:element name="Reason">
				<xs:simpleType>
					<xs:restriction base="xs:NMTOKEN">
						<xs:enumeration value="RepositoryMissing"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
</xs:schema>
