<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
	xmlns:tns="http://www.example.org/Importing/" xmlns:imp="http://www.example.org/Imported/"
	xmlns:imp1="http://www.example.com/example" xmlns:imp2="http://www.example.com/example2"
	xmlns:po="http://www.example.com/IPO"
	xmlns:impwsdl="http://www.example.org/Imported/wsdl"
	xmlns:imp3="http://www.example.com/example3wsdl"
	xmlns:imp3_2="http://www.example.com/example2wsdl"
	xmlns:impex4="http://www.example.com/example4wsdl"
	xmlns:wsdl_schema2="http://www.example.org/Imported/wsdl_schema2"
	xmlns:ex3_1="http://www.example.com/example3_1wsdl"
	xmlns:ipo2="http://www.example.com/IPO2"
	xmlns:sch1="http://www.example.org/schema1"
	xmlns:ex5="http://www.example.com/example5"
	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
	targetNamespace="http://www.example.org/Importing/">

	<wsdl:import namespace="http://www.example.org/Imported/wsdl"
		location="Imported.wsdl" />
	<wsdl:import namespace="http://www.example.com/IPO"
		location="po.xsd" />

	<wsdl:types>
		<xsd:schema targetNamespace="http://www.example.org/Importing/">
			<xsd:element name="NewOperation">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="in" type="xsd:string" />
						<xsd:element name="in2" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
			<xsd:element name="NewOperationResponse">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="out" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
			<xsd:element name="NewOperationParameter">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element minOccurs="1" maxOccurs="1" name="string"
							type="xsd:string"></xsd:element>
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
			<xsd:element name="NewOperationParameter1">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element minOccurs="1" maxOccurs="1" name="string"
							type="xsd:string"></xsd:element>
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
		</xsd:schema>

		<xsd:schema>
			<xsd:import namespace="http://www.example.com/example"
				schemaLocation="example.xsd" />
			<xsd:import namespace="http://www.example.com/example5"
				schemaLocation="example5.xsd" />
				
			<xsd:element name="comment" type="xsd:string"/>
		</xsd:schema>

		<xsd:schema targetNamespace="http://www.example.com/example_noTNS">
			<xsd:import schemaLocation="noTargetNamespace.xsd" />
		</xsd:schema>

		<xsd:schema targetNamespace="http://OnlyProperlyImportedImport">
			<xsd:import namespace="http://www.example.com/example2"
				schemaLocation="example2.xsd" />
		</xsd:schema>

		<xsd:schema targetNamespace="http://OnlyProperlyImportedImport2">
			<xsd:import namespace="http://www.example.com/example"
				schemaLocation="example.xsd" />
			<xsd:import namespace="http://www.example.com/example2"
				schemaLocation="example2.xsd" />

			<xsd:element name="NewOperation">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="in" type="xsd:string" />
						<xsd:element name="in1" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
			<xsd:element name="NewOperationResponse">
				<xsd:complexType>
					<xsd:sequence>
						<xsd:element name="out" type="xsd:string" />
					</xsd:sequence>
				</xsd:complexType>
			</xsd:element>
		</xsd:schema>
		
		<xsd:schema targetNamespace="http://www.example.org/schema1"
			xmlns:sch2="http://www.example.org/schema2">
			
			<xsd:import namespace="http://www.example.org/schema2"/>
			
			<xsd:element name="comment" type="xsd:string"/>
			<xsd:element name="address" type="sch2:Address"/>
		</xsd:schema>
		
		<xsd:schema targetNamespace="http://www.example.org/schema2">
			<xsd:complexType name="Address">
				<xsd:sequence>
					<xsd:element name="name" type="xsd:string" />
					<xsd:element name="street" type="xsd:string" />
					<xsd:element name="city" type="xsd:string" />
				</xsd:sequence>
		    </xsd:complexType>
		</xsd:schema>
	</wsdl:types>

	<wsdl:message name="NewOperationRequest">
		<wsdl:part element="tns:NewOperation" name="containedType" />
		<wsdl:part element="sch1:address" name="innerType_address" />
		<wsdl:part element="imp1:comment" name="importedType_example.xsd" />
		<wsdl:part element="imp2:comment" name="importedType_example2.xsd" />
		<wsdl:part element="comment_NoTNS" name="importedType_noTargetNamespace.xsd" />
		<wsdl:part element="po:po_comment" name="importedType_po.xsd" />
		<wsdl:part element="impwsdl:ImportedOperation" name="importedType_Imported.wsdl" />
		<wsdl:part element="imp3:comment" name="importedType_Imported.wsdl_types_import" />
		<wsdl:part element="wsdl_schema2:comment" name="importedType2_Imported.wsdl" />
		<wsdl:part element="ex3_1:comment" name="importedType_Imported.wsdl_types_import_Imported_example3.xsd_Imported_example3_1.xsd" />
		<wsdl:part element="ipo2:po2_comment" name="importedType_po.xsd_po2.xsd" />
		<wsdl:part element="ex5:comment" name="importedType_example5.xsd" />
		<wsdl:part element="comment" name="importedType_inner" />
	</wsdl:message>
	<wsdl:message name="NewOperationResponse">
		<wsdl:part element="imp1:purchaseOrder" name="parameters" />
	</wsdl:message>
	<wsdl:portType name="PortType">
		<wsdl:operation name="NewOperation">
			<wsdl:input message="tns:NewOperationRequest" />
			<wsdl:output message="tns:NewOperationResponse" />
		</wsdl:operation>
	</wsdl:portType>
	<wsdl:portType name="PortTypeWithImportedMessageRef">
		<wsdl:operation name="NewOperation">
			<wsdl:input message="tns:NewOperationRequest" />
			<wsdl:output message="tns:NewOperationResponse" />
		</wsdl:operation>
	</wsdl:portType>
</wsdl:definitions>