Web Services Description Language (WSDL) Version 2.0: RDF Mapping

1. Introduction

Web Services Description Language is defined in XML, because XML is the standarda common format for exchange of structured information. The use of XML brings better interoperability toWSDL generators and parsers,parsers benefit of the wide availability of XML processing libraries, and the use of XML Schema makes the structure of WSDL well constrained, yet extensible. On the other hand, XML vocabulariesin general don't have clear composition rules,does not provide generic rules for composing different vocabularies, so combining for example the WSDL description of a Web service, the service's policies and other information (presumably expressed in XML) can be done in many significantly different ways (e.g. extending WSDL, extending the policy language, creating a special XML container for all the information etc.), and little interoperability can be expected when such combined documents are used.

For example, a policy can be combined with WSDL by adding the policy elements in WSDL service element. Equally, a WSDL description can be combined with a policy by adding the WSDL description as part of the policy. While the results should be similar (WSDL with policy information), they are in fact very different for the processing software, and a policy in WSDL cannot easily be used by software that doesn'tdoes not know WSDL.

In contrast, the Semantic web requiresallows knowledge from many different sources to be easily combined so that unexpected data connections can be used. For this purpose there is the Resource Description Framework (RDF), whose graph structurestructure, together with the use of URIs for identifying nodes makes it very easy for different documents to be brought together. If asome WSDL document describes a Web service, a policy document attaches constraints to the service and a general description specifies the author of the service, all this information can be merged and the resulting document will contain all thethree kinds of information associated with the single service.

The main objective of this specification is to present a standard RDF ([RDF]) and OWL ([OWL]) vocabulary equivalentto express WSDL 2.0, so that WSDL 2.0 documents can be transformed into RDF and merged with other Semantic Web data.

Note: the readers of this document are expected to have an understanding of the WSDL language and the WSDL component model;model (see [WSDL 2.0 Core Language]); this document is not a standalone specification of the WSDL ontology, independent of WSDL specification. Further, the readers are expected to have good knowledge of RDF and at least basic knowledge of OWL.

1.1 Naming and Notation Conventions

The ontology presented in this specification is based ondescribes concepts introduced in WSDL 2.0 (see [WSDL 2.0 Core Language] and [WSDL 2.0 Adjuncts]), from where we adopt the names for the ontology classes, properties and distinguished instances.

In WSDL 2.0, components and their properties are named with words separated with spaces, for example Interface Operation component with {message exchange pattern} property. In this document, we write all WSDL 2.0 components and properties in italic. In the WSDL ontology, we use the so-called camelCase, with upper-case first letter for class names (InterfaceOperation) and lower-case first letter for properties (messageExchangePattern). We write all the WSDL ontology identifiers in monospace.

The above naming transformation (remove spaces, use camelCase) is used for the majority of components and their properties modeled in our ontology, with several exception indicated in the text in this specification. One recurring exception is that the multivalued properties (like Interface.{interface operations}) are not modeled as a single plural property (say interfaceOperations) but instead as a singular property to be used multiple times (i.e. interfaceOperation in our case), as the order of the values is irrelevant in WSDL.

In the mapping tables below, we use a fairlysimple triple syntax, each triple on one line. Variables to be filled in (like generated IDs and property values) are in angle brackets, for example <id> generally means the ID of the current component. Literal values are in double quotes, optionally indicating the data type after double caret, for example "<code>"^^xs:int for HTTP status codes. The default data type is xs:string. Finally, comments are in parentheses and italic (like this).

This specification uses predefined namespace prefixes throughout; they are given in the following list. Note that the choice of any namespace prefix is arbitrary and not semantically significant (see [XML Namespaces]).

wsdl

http://www.w3.org/2005/10/wsdl-rdf#http://www.w3.org/ns/wsdl-rdf#

wsdlx

http://www.w3.org/2006/01/wsdl-extensions#http://www.w3.org/ns/wsdl-extensions#

wsoap

http://www.w3.org/2006/01/wsdl/soap#http://www.w3.org/ns/wsdl/soap#

whttp

http://www.w3.org/2006/01/wsdl/http#http://www.w3.org/ns/wsdl/http#

wrpc

http://www.w3.org/2006/01/wsdl/rpc#http://www.w3.org/ns/wsdl/rpc#

rdf

http://www.w3.org/1999/02/22-rdf-syntax-ns#

xs

http://www.w3.org/2001/XMLSchema#

sawsdl

http://www.w3.org/2007/01/sawsdl#

ex

http://example.com/#

1.2 Organization of this specification

The remainder of this specification is split into three sections and an appendix:

• Section 2 describes the ontology for representing WSDL information and showshows the formal mapping tables,
• Section 3 shows the RDF form of a fullcomplete example WSDL document,
• Section 4 details the differences in modeling between the component model of WSDL and the ontology presented in this document,
• Appendix A contains the full listing (in OWL) of the WSDL ontology.

2. WSDL Ontology

This section describes the OWL ontology for WSDL, comparing it to the WSDL component model defined in [WSDL 2.0 Core Language] and [WSDL 2.0 Adjuncts]. The text in this section aims to be a verbosecomprehensive explanation of the mapping, and the formal normative mappings are specified in the mapping tables at the end of each subsection. Note that the URIs defined by the WSDL 2.0 specification (binding types, operation styles, message exchange patterns etc.) defined by the WSDL 2.0 specificationare not repeated in the mapping tables.

This section mayalso touches briefly touchon some differences between the OWL ontology and the component model, but for the full account and rationalesof these differences and for the rationales see section 4.

The RDF mapping for the core WSDL components defined in [WSDL 2.0 Core Language] is described in section 2.1. All theseWSDL components are extensible, so section 2.2 describes how extensions are mapped to RDF. The following sections, from 2.3 to 2.7,2.7, describe the mapping for the various adjuncts specified in [WSDL 2.0 Adjuncts].

2.1 Core WSDL Components

All theThe main components of WSDL are represented as classes in the WSDL ontology: Description, Interface, Binding and Service, as described in the following subsections. This means that every interface, binding and service described by WSDL will be mapped to a single instance in the RDF representation, linked from the instance mapped from the top-level Description component.representation.

2.1.1 Description class

The top-level WSDL component — description — is mapped to a single instance of the class Description, which uses the properties interface, binding and service to point to its contents,constituents, i.e. all the interfaces, bindings and services. Note that since we don'tdo not model element declarations and type definitions further than just the QNames, we also don'tdo not reference them from the Description instance. This also means that while all WSDL component models implicitly contain all XML Schema simple type definitions, the RDF mapping does not show them.

Note that aA mapping of a single WSDL document (together with any imports or includes) will always result in a single instance of the Description class. However, there can be multiple individuals of the class Description in a knowledge base that contains the information from multiple WSDL documents. The core WSDL specification does not consider the case of combining multiple independent WSDL documents and it doesn'tdoes not mandate that independent documents describeconsistently describe components with the same name. This is, however, an assumption when combining multiple WSDL documents inthe RDF representation.representation of multiple WSDL documents. See more on this point in section 4.2.

2.1.2 Interface classes

All WSDL interfacesinterface components are represented in RDF as instances of the Interface class. WSDL interfaces can extend other WSDL interfaces, which is indicated by the property extends. Interfaces may have operations and faults, represented as instances of the InterfaceOperation and InterfaceFault classesclasses, and each pointed to with the properties interfaceOperation and interfaceFault, respectively.

There are a number of properties applicable to InterfaceOperation instances:instances (corresponding to the properties of the WSDL Interface Operation component):

• messageExchangePattern property points to an instance of the class MessageExchangePattern and thus indicates the message exchange pattern (MEP) used by this operation; there can be only one MEP on one operation
• operationStyle property points to an instance of the class OperationStyle and indicates that the operation adheres to the given style; there can be multiple operation styles on a single operation
• interfaceMessageReference and interfaceFaultReference properties point to instances of InterfaceMessageReference and InterfaceFaultReference classes respectively, which are described later. Interface faults, in turn, only contain a single pointer to an element declaration, represented by the property elementDeclaration and pointing to a QName instance. Interface message referencesrespectively.

Instances of InterfaceMessageReference and interface fault referencesInterfaceFaultReference can indicate their direction — input message references and input fault references all belong to the class InputMessage and output message references and output fault references all belong to the class OutputMessage. Further, both message references and fault references indicate the appropriate message labels (instances of MessageLabel, representing particular messages in the operation's MEP) using the property messageLabel. (In section 2.3 we describe how message exchange patterns are modeled in our RDF mapping.)

Furthermore, interface message referencesinstances of InterfaceMessageReference and of InterfaceFault point to element declarations (as QName instances) using the property elementDeclaration and theyspecify their message content model with the property messageContentModel, indicating one of the four possible instances of the class MessageContentModel. And finally interface fault referencesfinally, instances of InterfaceFaultReference refer to their interface faults directly using the property interfaceFault.

2.1.3 Binding classes

WSDL bindingsbinding components are represented in RDF as instances of the class Binding. To indicate a particular interface for which binding information is specified with this WSDL binding, the particular Interface instance is pointed to using the property binds. Binding types (for example SOAP binding or HTTP binding, as specified in [WSDL 2.0 Adjuncts]) are themselves classes in RDF, so a binding type is indicated by belonging to the appropriate class (using the property rdf:type).

As the structure of bindings follows the structure of interfaces, we represent binding operations and faults using the classes BindingOperation and BindingFault respectively. The parent bindingBinding points to them using the similarly named properties bindingOperation and bindingFault. Binding operations further contain message and fault references, represented as instances of the classes BindingMessageReference and BindingFaultReference, and pointed to by the properties bindingMessageReference and bindingFaultReference.

Within this structure, each component points to the appropriate component from the interface structure, i.e. binding operationsBindingOperation instances point to interface operations, binding faults respectivelyInterfaceOperation instances, BindingFault instances point to interface faultsInterfaceFault instances and binding messageBindingMessageReference and fault referencesBindingFaultReference instances point to interface messageInterfaceMessageReference and fault references.InterfaceFaultReference instances. To provide these pointers, we use the property binds between the pairs of components.

Finally, each component is supposed to contain extensions that provide the actual binding information. For the description of handling such extensions see section 2.2 and for the specific bindings included in WSDL 2.0 specification, see sections 2.6 and 2.7.

2.1.4 Service classes

WSDL services are represented in RDF as instances of the class Service. Each instance must pointpoints to a single interface; for this purpose we reuse the property implements. Also, each service has one or more endpoints, to which it points using the property endpoint.

Endpoints are represented as instances of the class Endpoint, with two notable properties: a mandatory single usesBinding property points to the binding used by this endpoint, and an optional single address points to the network resource which actually offers the service.

2.2 Handling Documentation, Features, Properties and GenericExtensions and Documentation

In order to enable evolution and reusability of the language, WSDL 2.0 allows extensions on all components. In fact, there are multipletwo types of extensibility in WSDL 2.0: explicit extension points, abstract featuresand properties, and genericXML-based extensions.

Extension points are those places in WSDL where a number of options is defined by the WSDL 2.0 specification, but the list is open. For example, interface operations follow message exchange patterns (MEPs), and while WSDL 2.0 provides a list of eightsome predefined MEPs, new ones can be specified by WSDL 2.0 users. Similarly, WSDL 2.0 specifies two bindings (SOAP and HTTP), but more bindings are expected to be specified in the future, either by the WS-Description Working Group or by any interested third parties. Often, extension points use URIs to refer to the various options, but manyand these URIs are then reflected in the RDF form as the appropriate property values. Additionally, some of the extensions also introduce data that needs towould be modeleduseful in the RDF representation, in which case it is the responsibility of the extension designers to describe their mappings to RDF. Features and properties represent abstract piecesThis document describes the mapping of functionality and their run-time parameters. Mostly, features and properties simply use URIs to identify their semantics, and this easily translates into RDF, as described below in section 2.2.1 .the extensions defined together with the WSDL 2.0 specification.

Apart from the envisioned extensibility points and the abstract functionality extensibility using features,points, WSDL 2.0 allows the XML WSDL documents to contain any "foreign" elements and attributes, so that unexpectedany extensions, even ones that change the core WSDL semantics, can also be realized. Mapping suchThe actual meaning of general WSDL extensions to RDF is described in section 2.2.2 . In additionis, by definition, unknown to the extensions, allcore WSDL XML elements can contain documentation. Such documentation can consist of human-readable text or machine-processible elementsspecification, and attributes, butit isn't modeled in more detail in WSDL 2.0. Therefore inis equally unknown to the RDF mapping we represent documentation as XML literals that contain(apart from the wsdl:documentation element and all its children. The literal is attachedpredefined extensions coming with WSDL 2.0, whose mapping to the appropriate componentRDF is described in the RDF representation using the property documentation . Table 2-15.  Mapping Documentation to RDF XML Form RDF Form <wsdl:...>     <wsdl:documentation ...>         ...     </wsdl:documentation> </wsdl:...> <parentComponentId> wsdl:documentation " <wsdl:documentation ...>         ...     </wsdl:documentation> "^^rdf:XMLLiteral (note that the whitespace inside the XML literal above is copied from the XML) 2.2.1 Features and properties Every feature component is mapped to RDF as an instance of the class Feature . This instance is identified by the feature's IRI, i.e. the value of the {ref} property of the Feature component. Features can be required or optional. In RDF, this is indicated by the property that points from the feature's parent component to the feature — it is either the requiresFeature or the offersFeature property. Property components in WSDL 2.0 serve to specify or constrain the value that a property can have at run time. As one of the few naming differences between the RDF representation and the WSDL 2.0 component model, the property components are represented as instances of the class PropertyValue , pointed to from the property's parent component using the propertyValue RDF property. Every PropertyValue instance points to the actual property whose value it specifies, using the RDF property named property . PropertyValue instances also either specify the actual value of the property (using the RDF property propertyActualValue ) or they constrain the possible values of the property using a type definition identified by its QName (referenced from the PropertyValue instance by the RDF property propertyValueType ). Table 2-16.  Mapping Feature Components to RDF Property RDF Form {ref} <ref> rdf:type wsdl:Feature {required} (for required) <parentComponentId> wsdl:requiresFeature <ref> (for not required) <parentComponentId> wsdl:offersFeature <ref> Table 2-17.  Mapping Property Components to RDF Property RDF Form   (id generated per IRI-References for WSDL 2.0 Components ) <id> rdf:type wsdl:PropertyValue <parentComponentId> wsdl:propertyValue <id> {ref} <id> wsdl:property <ref> {value} <id> wsdl:propertyActualValue "<value>"^^rdf:XMLLiteral (the value is an xml literal without the enclosing <wsdl:value> element) {value constraint} <id> wsdl:propertyValueType <qname> (for qname mapping see Table 2-2 ) 2.2.2 Generic extensions The actual meaning of general extensions is, by definition, unknown to the WSDL specification, and it is equally unknown to the RDF mapping.following sections). Therefore every extension should specify how it is mapped to RDF. For example, the SOAP and HTTP bindings in WSDL 2.0 add many properties to the core binding components and this document defines how these particular properties are expressed in RDF. The mapping of WSDL extensions to RDF therefore depends on the understanding of those extensions.

This section describes how unknown extensions are handled when mapping a WSDL document into RDF.In WSDL 2.0, extensions can be marked as mandatory (or required). Such extensions may alter the semantics of the extended components in ways that invalidate the existing semantics. Since the RDF representation of WSDL intends to represent the semantics of the WSDL data, components with required extensions mustwill be mapped to RDF according to the rules of the extension, not according to the rules specified in this document. If a processor that does the mapping of a WSDL document to RDF does not understand a particular mandatory extension (in other words, when it encounters an unknown mandatory extension, it must notcannot map the component that contains that extension into any generic RDF representation, in other words the component will not be present in the resulting RDF data. This is to avoid confusing processors that don'tdo not understand a mandatory extension — RDF encourages the principle of ignoring the unknown parts of an RDF graph (partial understanding) and there is no agreed mechanism of marking some parts as mandatory, therefore if we decided to map the known WSDL according to our rules and addabove, the potential changes introduced by the mandatory unknown extensions in the graph, theycould be ignored by some RDF processors, violating the mandatoriness. Finally unknown optional extensions (not mandatory) can be represented in the RDF representation using the properties extensionElement and extensionAttribute . Extension elements are represented as XML literals containing the whole extension XML elements (and should also include all the in-scope namespaces and the XML base); extension attributes are represented as instances of the class ExtensionAttribute ,which in turn have a name (property attributeName pointing to a QName ) and a value (property rdf:value pointing to a literal containingwould violate the attribute value). Such representation of unknownway WSDL considers them mandatory.

Unknown optional extensions is not intended toalso cannot be used by processors that understand those extensions; instead such processors should reinterpret the XML literals and map them into the appropriate RDF extensions of the rest of the RDF representation. Table 2-18.  Mapping Unknown Extensionsmapped to RDF XML Form RDF Form <wsdl:...>     <ex:unknown ...>         ...     </ex:unknown> </wsdl:...> <parentComponentId> wsdl:extensionElement " <ex:unknown ...>         ...     </ex:unknown> "^^rdf:XMLLiteral (note that the whitespace inside the XML literal above is copied from the XML) <wsdl:...>     <ex:unknown wsdl:required="true" ...>         ...     </ex:unknown> </wsdl:...> (cannot be mapped, thewith any mapping rules defined in this document, because their meaning ofis unknown. However, the parent component is unknown) <wsdl:... ex:unknown="val">     ... </wsdl:...> <parentComponentId> wsdl:extensionAttribute <genId> <genId> rdf:type wsdl:ExtensionAttribute <genId> wsdl:attributeName <qname> <genId> rdf:value "val" (genIdmapped into RDF as though the unknown optional extension was not present at all. Effectively, this WSDL RDF mapping ignores unknown optional extensions.

In addition to the extensions, all WSDL XML elements can also contain documentation. Such documentation can consist of human-readable text or machine-processible elements and attributes, but it is a newly generated unique URI) (for qnamenot modeled in more detail in WSDL 2.0. This WSDL RDF mapping see Table 2-2 )does not represent documentation in the resulting RDF graph, because it would be an XML literal with no explicit meaning.

2.3 Message Exchange Patterns

WSDL 2.0 defines an extensible set of message exchange patterns (MEPs). There are 8 predefined MEPs,MEPs (three in [WSDL 2.0 Adjuncts] and five in [WSDL 2.0 Additional MEPs]), each following one of the three predefined fault propagation rules. Every WSDL MEP defines a set of message labels by which message references in operations can position themselves within the pattern.

In the RDF representation of WSDL, message exchange patterns are represented as instances of the class MessageExchangePattern. The three predefined fault propagation rules are disjoint subclasses of that class, named NoFaults, FaultReplacesMessage and MessageTriggersFault.

All MEPs are identified by IRIs, and the RDF ontology for WSDL only puts the MEPs in the correct classes;assigns classes to MEPs; for example http://www.w3.org/2006/01/wsdl/in-onlyhttp://www.w3.org/ns/wsdl/in-only is an instance of the class NoFaults. The message labels, however, are plain string names, and the RDF ontology for WSDL gives each of them an IRI formed by the MEP IRI, the hash sign '#' and the actual message label, and these IRIs are referenced from the MEPs with the property definesMessageLabel. Any newly created MEPs should also provide IRIs for the message labels, as the RDF mapping depends on being able to identify the message labels on interface message references.

The following mapping table only shows the message label URIs defined by the WSDL ontology for the message labels defined by the message exchange patterns from [WSDL 2.0 Adjuncts] and [WSDL 2.0 Additional MEPs].

2.4 Predefined Extensions

WSDL 2.0 Adjuncts contain a single predefined extension, called Operation Safety, which adds a property to interface operation components to indicate whether an interface operation is known to be safe in terms of [Web Architecture].

In the RDF representation of WSDL, we introduce the class SafeInteraction —, and we use the Semantic Annotations for WSDL and XML Schema ([SAWSDL]) property modelReference to annotate any InterfaceOperation instance that is also a SafeInteraction isasserted to be safe.

Note: the fact that the SAWSDL modelReference RDF property is used in this WSDL RDF mapping does not introduce the dependency that WSDL processors or WSDL RDF mapping implementations would need to understand the SAWSDL extension.

2.5 Operation Styles

WSDL 2.0 predefines 3 operation styles — RPC style, IRI style and Multipart style. These styles are identified with their IRIs, which are, in the RDF ontology makesontology, instances of the class OperationStyle.

The RPC style additionally introduces the property {rpc signature}, which is represented in RDF using the property signature, whose value is a literal whose datatype is the signature type defined by WSDL 2.0.WSDL 2.0. The signature property can be attached to interface operations following the RPC style to indicate the parameter order for the operation.

Note: the value of the RPC signature property uses QNames so it can only be parsed successfully if all in-scope namespace bindings are available.

2.6 SOAP Binding

WSDL bindings that bind to SOAP are identified (using the property rdf:type) as instances of the class http://www.w3.org/2006/01/wsdl/soaphttp://www.w3.org/ns/wsdl/soap. Every such binding must indicateindicates the SOAP version that it uses, this is done with the property version (with a value "1.2", for example, meaning SOAP version 1.2). Every binding also must specifyspecifies with the property protocol the underlying protocol that is uses.

Each SOAP binding operation must specifyspecifies the SOAP message exchange pattern it uses — the appropriate URI from the SOAP specification is pointed to using the property soapMEP. The ontology also introducesrange of this property is the SOAP 1.2 class SOAPMessageExchangePatternhttp://www.w3.org/2006/02/soap12/abstractions#classOfMEPs that contains all the SOAP MEPs. Some bindings (especially those that are not specific to any interface) will rely on defaulting to set the SOAP message exchange pattern, this default is captured using the property defaultSoapMEP.

SOAP binding operations can additionally specify the value of the action parameter (known as SOAP action) for the initial message, using the property action.

Binding faults in the SOAP binding can specify two properties — fault code and fault subcodes. Both fault code and subcodes are QNames, and they are pointed to using the properties faultCode and faultSubcodes. The latter points to an RDF sequence (rdf:Seq)(rdf:Seq) which contains all the subcodes.

At any level within a SOAP binding, components can declare the use of a SOAP module. Required modules are pointed to using the property requiresSOAPModule and optional modules are pointed to using the property offersSOAPModule — both of these properties point directly from the parent component to the SOAP module, as identified by its URI (parameter {ref} of the SOAP Module component).

Message references and faults in SOAP bindings can further declare that they require or offer a specific SOAP headers. To do this, the properties requiresHeader and offersHeader can point to an instance of the class SOAPHeaderBlock, which then uses the property elementDeclaration to specify the exact element that represents the header. Instances of SOAPHeaderBlock can also belong to the class MustUnderstandSOAPHeaderBlock, which means that this SOAP header will be marked as mandatory (mustUnderstand="true") in the message.

Apart from these SOAP-binding-specific properties, the SOAP binding reuses underlying protocol properties, for example some HTTP binding properties when the underlying protocol is HTTP. The following section describes the HTTP binding properties.

2.7 HTTP Binding

WSDL bindings that bind to HTTP are identified as instances of the class http://www.w3.org/2006/01/wsdl/httphttp://www.w3.org/ns/wsdl/http. The HTTP bindings that make use of HTTP cookies are further identified as instances of the class HTTPBindingWithCookies.

HTTP binding operations can specify a number of HTTP parameters: operation-specific location (and what to do with parameters that are not serialized in it — ignore uncited), HTTP method, input and output and fault serialization, and query parameter separator. These parameters are represented in RDF with the properties location, locationIgnoreUncited, method, inputSerialization, outputSerialization, faultSerialization and queryParameterSeparator. The HTTP method and query parameter separator can also be specified on the binding level as defaults, especially in bindings that are not specific to any particular interface. Those defaults are preserved using properties defaultMethod and defaultQueryParameterSeparator. The values of all these properties are literals, same as in the XML syntax of WSDL.

Message references and faults in an HTTP binding can specify the use of extra HTTP headers. Required headers are pointed to using the property requiresHeader, whereas optional headers are referenced using the property offersHeader. Both properties point to an instance of the class HTTPHeader. Each HTTPHeader instance has a property headerName that specifies the name of the header, and a property typeDefinition which defines the simple type of the header value.

Message references and faults can also specify the transfer codingcontent encoding using the property transferCodingcontentEncoding with a literal string value, as in the XML representation; and binding operations or even bindings may define the default transfer codingcontent encoding values using the property defaultTransferCodingdefaultContentEncoding. Finally, faults can further specify the HTTP status code they will be accompanies with, using the property errorCode.

Service endpoints that use an HTTP binding can specify access authentication parameters, in particular authentication scheme and realm. These parameters are reflected with the properties authenticationScheme and authenticationRealm with string values.

3. Example WSDL document in RDF form

The following is a listing of the RDF form of the WSDL description of the initial GreatH Web Service (listed as example 2-1) from the WSDL 2.0 primer (in triple notation):

@prefix wsdl:  <http://www.w3.org/2005/10/wsdl-rdf#><http://www.w3.org/ns/wsdl-rdf#> .
    
<http://greath.example.com/2004/wsdl/resSvc#wsdl.description()>     
     a wsdl:Description ;
     wsdl:interface <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> ;
     wsdl:binding <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)> ;
     wsdl:service <http://greath.example.com/2004/wsdl/resSvc#wsdl.service(reservationService)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)>     
     a wsdl:Interface ;
     wsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> ;
     wsdl:interfaceOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)>     
     a wsdl:InterfaceFault ;
     wsdl:elementDeclaration _:L9C14 .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFaultReference(reservationInterface/opCheckAvailability/Out/invalidDataFault)>     
     a wsdl:InterfaceFaultReference ;
     a wsdl:OutputMessage; 
     wsdl:messageLabel <>; 
     wsdl:interfaceFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/In)>     
     a wsdl:InterfaceMessageReference ;
     a wsdl:InputMessage; 
     wsdl:elementDeclaration _:L22C18 ;
     wsdl:messageLabel <>; 
     wsdl:messageContentModel wsdl:element .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/Out)>     
     a wsdl:InterfaceMessageReference ;
     a wsdl:OutputMessage; 
     wsdl:elementDeclaration _:L32C18 ;
     wsdl:messageLabel <>; 
     wsdl:messageContentModel wsdl:element .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)>     
     a wsdl:InterfaceOperation ;
     wsdl:messageExchangePattern <http://www.w3.org/2004/03/wsdl/in-out> .
     wsdl:interfaceMessageReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/In)> ;
     wsdl:interfaceMessageReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceMessageReference(reservationInterface/opCheckAvailability/Out)> ;
     wsdl:interfaceFaultReference <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFaultReference(reservationInterface/opCheckAvailability/Out/invalidDataFault)> ;
<http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)>     
     a wsdl:Binding ;
     a  <http://www.w3.org/2006/01/wsdl/soap>;<http://www.w3.org/ns/wsdl/soap>; 
     wsdl:binds <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> ;
     wsdl:bindingFault <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingFault(reservationSOAPBinding/invalidDataFault)> ;
     wsdl:bindingOperation <http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingOperation(reservationSOAPBinding/opCheckAvailability)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingFault(reservationSOAPBinding/invalidDataFault)>     
     a wsdl:BindingFault ;
     wsdl:binds <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceFault(reservationInterface/invalidDataFault)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.bindingOperation(reservationSOAPBinding/opCheckAvailability)>     
     a wsdl:BindingOperation ;
     wsdl:binds <http://greath.example.com/2004/wsdl/resSvc#wsdl.interfaceOperation(reservationInterface/opCheckAvailability)> .
<http://greath.example.com/2004/wsdl/resSvc#wsdl.service(reservationService)>     
     a wsdl:Service ;
     wsdl:implements <http://greath.example.com/2004/wsdl/resSvc#wsdl.interface(reservationInterface)> .
     wsdl:endpoint <http://greath.example.com/2004/wsdl/resSvc#wsdl.endpoint(reservationService/reservationEndpoint)> ;
<http://greath.example.com/2004/wsdl/resSvc#wsdl.endpoint(reservationService/reservationEndpoint)>     
     a wsdl:Endpoint ;
     wsdl:usesBinding <http://greath.example.com/2004/wsdl/resSvc#wsdl.binding(reservationSOAPBinding)>; 
     wsdl:address <http://greath.example.com/2004/reservation> .
_:L9C14     
     a wsdl:QName .
     wsdl:localName "invalidDataError"; 
     wsdl:namespace "http://greath.example.com/2004/schemas/resSvc"; 
_:L22C18     
     a wsdl:QName .
     wsdl:localName "checkAvailability"; 
     wsdl:namespace "http://greath.example.com/2004/schemas/resSvc"; 
_:L32C18     
     a wsdl:QName .
     wsdl:localName "checkAvailabilityResponse"; 
     wsdl:namespace "http://greath.example.com/2004/schemas/resSvc"; 

4. Differences from the WSDL Component Model (Informative)

WSDL defines a component model which consists of components, component properties and sets of components. This document supplies an ontology (i.e., a set of classes, properties, datatypes, and distinguished individuals) for representing WSDL data. This ontology contains axioms which express some of the constraints the WSDL specification imposes on legal sets of WSDL components whether indirectly (via the XML Schema constraints on the infoset which canonically encodes WSDL component models) or directly (via the natural language of the WSDL specs, or the corresponding Z formalizations of that language).

RDF, RDFS, and OWL are all less (and differently) expressive than the subset of Z used to formalize the WSDL specification, and are designed for different purposes. In a nutshell, RDF, RDFS, and OWL are relatively small fragments of first order logic, whereas Z encompasses all of first order logic plus set theory. Z supports validation of component models, that is, the acceptance or rejection of component models. This includes type checking, consistency checking, and the verification of integrity constraints. The current set of Semantic Web languages focus on inference and integration of information. To take a simple example, if a Z checkable representation of an Interface component lacks a {name} component property, a Z based validator will complain that that representation is ill formed (given the WSDL specification). An OWL reasoner encountering it will, all other things being equal, conclude that there is such a property, even though the reasoner has not seen it yet. In general, Semantic Web based descriptions of Web services using the WSDL conceptual framework tend to be looser than what the WSDL specification prescribes.

This difference effectively introduces two classes of documents that use the ontology from this document:

1. RDF documents resulting from translating valid WSDL documents,
2. arbitrary RDF documents written using the WSDL ontology.

This document focuses on the mapping from valid WSDL component models, and this section in particular talks about differences between a valid component model and its RDF representation.

However, we must note that arbitrary RDF, RDFS, or OWL documents that use the WSDL ontology may describe component models that are incomplete or even illegal. For example, from the point of view of arbitrary RDF documents that use the WSDL ontology, interfaces don'tdo not need to belong to any Description. Therefore, the subsections also contain notes about arbitrary RDF documents detailing further differences that an application consuming WSDL RDF data can encounter in documents that are not the direct result of mapping a valid WSDL document into its RDF form. The last subsection (section 4.5) then describes those constraints unenforced by the WSDL, that do not fit in any other subsection above it.

4.1 Component naming

In the RDF representation, all WSDL components are identified with their respective component designators (see [WSDL 2.0 Core Language] appendix C IRI-References for WSDL 2.0 Components), which are URIs generally constructed from the name and namespace of the component and from its parent component hierarchy. The original names and namespaces are not explicitly modeled in the RDF representation, which intends to convey the semantic meaning of the WSDL component, not the WSDL serialization details.

In some situations we can see the RDF representation to be used as an exchange syntax for WSDL. While it'sit is not an intended use, it is possible that in some systems the XML syntax will be lost or inaccessibly hidden in several layers of processing software. Such an application that only receives the RDF form of WSDL can still need to reconstruct the original component names, for example if it uses an API that identifies WSDL operations by their parent interface's QName and the operation name.

The component designators put the names of the components in the fragment identifier part of the resulting URIs. On the Web (see [Web Architecture]), the interpretation of fragment identifiers is defined by the MIME media type of the representation of the resource identified by the URI without the fragment identifier. In our particular case, we expect that the namespace URI identifies an application/wsdl+xml document so that the constructed component designator fragment identifiers can have their intended meaning. An application working with the RDF representation of WSDL can reconstruct the names of the components by reversing the process that resulted in the component designator, for example for a URI http://example.com/service#wsdl.interfaceOperation(TicketInterface/BookTicket) we could reconstruct that the name of the interface is "TicketInterface" in the namespace http://example.com/service and that the operation is named "BookTicket".

Such decomposition is only valid, though, if the URI http://example.com/service identifies a document of MIME media type application/wsdl+xml, as explained above. Checking the MIME media type of every resource identified by a URI in an RDF graph could be prohibitively slow for some applications, therefore it may be practical (albeit not entirely correct) simply to assume the correct media type and deconstruct the component names without the preceding media type check.

Note about arbitrary RDF documents: in general, it is possible to assert about any resource (identified by any kind of URI) that it is, for example, a WSDL operation, and if an application tries to deconstruct that URI according to WSDL component designator specification, it may find that the URI doesn'tdoes not conform to the syntax (e.g. http://example.com/service/operation) or, by accident or malice, it does conform to the syntax but doesn'tdoes not contain the correct data (e.g. http://example.com/service#wsdl.interface(TicketInterface) that is marked to be a WSDL operation, not an interface as it would seem).

4.2 Documents, imports and includes

In the XML syntax for WSDL, documents can be included and imported, allowing for modularization while keeping the ability to validate that a WSDL document (plus all the includes and imports) doesn'tdoes not use any unknown components. Such modularization is lost when the WSDL files are parsed into a component model, therefore a straigtforward transformation of such a component model into RDF will result in a single RDF document.

As one exception, all references to element declarations and type definitions from XML Schema are done in the RDF representation by QName and we expect the applications processing this representation to have means of locating the appropriate descriptions for these QNames. We do not model XML Schema (or any other) type and element descriptions in this ontology.

Note about arbitrary RDF documents: RDF data can be split into any number of pieces, which can be put together by the processing application as appropriate. If a piece of WSDL/RDF description uses an unknown component (e.g. an interface described in one document may extend other interfaces, not described in this document), the application may, if necessary, attempt to locate the description of the unknown component, for example using its identifier IRI. Note that RDF does not provide a standard generic way of including external data, so any inclusion is application-specific.

Additionally, a single RDF document may also contain multiple unrelated Descriptions, that is, it may be an aggregation of many unrelated WSDL documents, and this may have unexpected results if the aggregated WSDL data contains conflicts, i.e. different definitions of components with the same name; especially when dealing with different versions of descriptions of the same entities.

4.3 Component references

In the XML representation of WSDL, components are referred to using their names, and extensibility points usually use IRIs to identify things. All these references are, from XML point of view, literals. In the RDF representation, on the other hand, most references are direct, using the particular identifier IRIs, not represented as literals. For example, most instances representing components are identified with their component designators (see [WSDL 2.0 Core Language] appendix C IRI-References for WSDL 2.0 Components) and all references point directly there — an operation within a binding points to its respective interface operation using the interface operation component designator IRI, whereas in the XML syntax the operations are correlated using the message label.

As a notable exception, references to type definitions and element declarations (usually from XML Schema) are represented as instances of our class QName, with local part represented as literal and the namespace as a resource. This might change if a standard RDF representation for XML Schema element declarations and type definitions is developed — then direct references to the URIs used in that representation would be used.

Additionally, certain componentsthe SOAP Module component in WSDL (Feature, SOAP Module) are only pointers, theyis really only havea singlepointer: it has a literal property {ref} that points tocontains an external thing. For example,IRI identifying the feature component only carriesSOAP module, and a property {required} that indicates whether the URIuse of the feature.that SOAP module is required. While these componentsthis component can contain documentation and extensions in WSDL, we chose to represent these componentsit as a direct linkslink from the parent component to the target feature ormodule, as the indirection seems to add very little value and introduces naming difficulties (see description of Property— we would have to have class for the SOAP Module component mappingwhich would contain a pointer to SOAP Module. The requiredness of the SOAP Module is expressed in section 2.2.1 .)the type of the property that points to the module — the parent component either offersSOAPModule or requiresSOAPModule.

4.4 Representing properties with classes

In certain cases the RDF mapping introduces classes where the WSDL 2.0 component model has a property with a limited number of values. For instance, instead of having a direction property on message and fault references, with the values either "in" or "out", we introduce two classes, InputMessage and OutputMessage, and the direction of a particular message or fault reference is then indicated by belonging to either of these classes. Similarly, binding types are classes and the type of a particular binding is indicated by its belonging to that class; we predefine the two classes for the two bindings that are part of WSDL 2. Finally, the operation safety property is represented with the class SafeInteraction , and safe operations are instances of this class. On a similar note, in the case of features, the flag that a feature is required is not modeled as a property of the feature component, required features are instead pointed to using the RDF property requiresFeature , whereas optional featuresSimilarly, binding types are pointedclasses and the type of a particular binding is indicated by its belonging to usingthat class; we predefine the property offersFeature .two classes for the two bindings that are part of WSDL 2.

4.5 Other WSDL restrictions not enforced by the ontology

As already mentioned, the validation-oriented WSDL specification and especially its Z formalization capture a number of restrictions and limitations that are not expressed in the RDF ontology. None of these restrictions or limitations can be violated when a valid WSDL document is mapped into its RDF form. When the RDF data is directly manipulated, for example merged with other RDF data (for example other WSDL documents mapped into RDF), or when new data is created that uses the WSDL ontology, further significant WSDL constraints might be violated:

• In WSDL, components of different types do not overlap, e.g. an interface is always a different thing from a binding (even if they have the same name), but an arbitrary RDF document can assert that one resource is both an interface and a binding.
• In WSDL, a Description cannot directly contain interface operations or endpoints, for example; an endpoint is always in a service and interface operations are always in interfaces. The ontology does not enforce these restrictions so an arbitrary RDF file that is consistent with the ontology may describe a broken hierarchy of components.

5. References

[OWL]

OWL Web Ontology Language Reference, Mike Dean,Guus Schreiber, Editors. W3C Recommendation 10 February 2004 . Available at http://www.w3.org/TR/owl-ref/

[RDF]

Resource Description Framework (RDF): Concepts and Abstract Syntax, Graham Klyne, Jeremy J. Carroll, Editors. W3C Recommendation, 10 February 2004. Available at http://www.w3.org/TR/rdf-concepts/

[SAWSDL]

Semantic Annotations for WSDL and XML Schema, J. Farrell and H. Lausen, Editors. World Wide Web Consortium, 26 January 2007. This version of the "Semantic Annotations for WSDL and XML Schema" Specification is available is available at http://www.w3.org/TR/2007/CR-sawsdl-20070126/. The latest version of "Semantic Annotations for WSDL and XML Schema" is available at http://www.w3.org/TR/sawsdl/.

[Web Architecture]

Architecture of the World Wide Web, Volume One, Ian Jacobs, Norman Walsh, Editors. W3C Recommendation, 15 December, 2004. Available at http://www.w3.org/TR/2004/REC-webarch-20041215/ .

[WSDL 2.0 Core Language]

Web Services Description Language (WSDL) Version 2.0Version 2.0 Part 1: Core Language, R. Chinnici, M. Gudgin, J-J. Moreau, S. Weerawarana, Editors. World Wide Web Consortium, 2726 March 2006.2007. This version of the "Web Services Description Language (WSDL) Version 2.0Version 2.0 Part 1: Core Language" Specification is available is available at http://www.w3.org/TR/2006/CR-wsdl20-20060327.http://www.w3.org/TR/2007/WD-wsdl20-20070326. The latest version of "Web Services Description Language (WSDL) Version 2.0Version 2.0 Part 1: Core Language" is available at http://www.w3.org/TR/wsdl20/.

[WSDL 2.0 Adjuncts]

Web Services Description Language (WSDL) Version 2.0Version 2.0 Part 2: Adjuncts, R. Chinnici, H. Haas, A. Lewis, J-J. Moreau, D. Orchard, S. Weerawarana, Editors. World Wide Web Consortium, 2726 March 2006.2007. This version of the "Web Services Description Language (WSDL) Version 2.0Version 2.0 Part 2: Adjuncts" Specification is available at http://www.w3.org/TR/2006/CR-wsdl20-adjuncts-20060327.http://www.w3.org/TR/2007/WD-wsdl20-adjuncts-20070326. The latest version of "Web Services Description Language (WSDL) Version 2.0Version 2.0 Part 2: Adjuncts" is available at http://www.w3.org/TR/wsdl20-adjuncts/.

[WSDL 2.0 Additional MEPs]

Web Services Description Language (WSDL) Version 2.0: Additional MEPs, A. Lewis, Editor. World Wide Web Consortium, 26 March 2007. This version of the "Web Services Description Language (WSDL) Version 2.0: Additional MEPs" Specification is available at http://www.w3.org/TR/2007/WD-wsdl20-additional-meps-20070326. The latest version of "Web Services Description Language (WSDL) Version 2.0: Additional MEPs" is available at http://www.w3.org/TR/wsdl20-additional-meps/.

[XML Namespaces]

Namespaces in XML 1.0 (Second Edition), T. Bray, D. Hollander, andA. Layman, and R. Tobin, Editors. World Wide Web Consortium, 14 January 1999.16 August 2006. This version of the Namespaces in XML Recommendation is http://www.w3.org/TR/1999/REC-xml-names-19990114.http://www.w3.org/TR/2006/REC-xml-names-20060816. The latest version of Namespaces in XML is available at http://www.w3.org/TR/REC-xml-names/.http://www.w3.org/TR/xml-names.

Appendix A: The OWL Ontology Source

Note that the ontology is also available in a separate RDF file.

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:owl="http://www.w3.org/2002/07/owl#"
         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
          xmlns:wsdl="http://www.w3.org/2005/10/wsdl-rdf#"xmlns:wsdl="http://www.w3.org/ns/wsdl-rdf#"
         xmlns:xml="http://www.w3.org/XML/1998/namespace"
          xml:base="http://www.w3.org/2005/10/wsdl-rdf">xml:base="http://www.w3.org/ns/wsdl-rdf">

<owl:Ontology rdf:about="">
</owl:Ontology>

<owl:Class rdf:about="#Binding">
  <rdfs:comment>The type of a binding is indicated with rdf:type</rdfs:comment>
</owl:Class>

<owl:Class rdf:about="#BindingFault">
</owl:Class>

<owl:Class rdf:about="#BindingFaultReference">
</owl:Class>

<owl:Class rdf:about="#BindingMessageReference">
</owl:Class>

<owl:Class rdf:about="#BindingOperation">
</owl:Class>

<owl:Class rdf:about="#Description">
</owl:Class>

<owl:Class rdf:about="#Endpoint">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#address"/>
      <owl:maxCardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:maxCardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:Class  rdf:about="#Feature"> </owl:Class> <owl:Classrdf:about="#Interface">
  <rdfs:label>WDSL Interface</rdfs:label>
</owl:Class>

<owl:Class rdf:about="#InterfaceFault">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#messageContentModel"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="#InterfaceFaultReference">
</owl:Class>

<owl:Class rdf:about="#InterfaceMessageReference">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#messageContentModel"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:about="#InputMessage">
  <rdfs:comment>To be used by message references and fault references instead of direction property</rdfs:comment>
  <owl:disjointWith rdf:resource="#OutputMessage"/>
</owl:Class>

<owl:Class rdf:about="#OutputMessage">
  <rdfs:comment>To be used by message references and fault references instead of direction property</rdfs:comment>
</owl:Class>

<owl:Class rdf:about="#InterfaceOperation">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#messageExchangePattern"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:Class  rdf:about="#PropertyValue"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#propertyValue"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </owl:Class> <owl:Class rdf:about="#Property"> </owl:Class> <owl:Classrdf:about="#Service">
</owl:Class>

<owl:Class rdf:about="#MessageExchangePattern">
</owl:Class>

<owl:Class rdf:about="#MessageLabel">
</owl:Class>

<owl:ObjectProperty rdf:about="#definesMessageLabel">
  <rdfs:domain rdf:resource="#MessageExchangePattern"/>
  <rdfs:range  rdf:resource="#MessageLabel"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#address">
  <rdfs:domain rdf:resource="#Endpoint"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#binding">
  <rdfs:range  rdf:resource="#Binding"/>
  <rdfs:comment>To be used for pointing to a Binding from Description</rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#usesBinding">
  <rdfs:range  rdf:resource="#Binding"/>
  <rdfs:comment>To be used for pointing to a Binding from Endpoint</rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#bindingFault">
  <rdfs:range  rdf:resource="#BindingFault"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#bindingOperation">
  <rdfs:range  rdf:resource="#BindingOperation"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#bindingMessageReference"> 
  <rdfs:range  rdf:resource="#BindingMessageReference"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#bindingFaultReference"> 
  <rdfs:range  rdf:resource="#BindingFaultReference"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#typeDefinition">
  <rdfs:range  rdf:resource="#QName"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#elementDeclaration">
  <rdfs:range  rdf:resource="#QName"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#endpoint"> 
  <rdfs:range  rdf:resource="#Endpoint"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#extends">
  <rdfs:range  rdf:resource="#Interface"/>
  <rdfs:domain rdf:resource="#Interface"/>
</owl:ObjectProperty>

<owl:Class rdf:about="#QName">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#localName"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#namespace"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:DatatypeProperty rdf:about="#localName"> 
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#NCName"/>
</owl:DatatypeProperty>

<owl:ObjectProperty rdf:about="#namespace"> 
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="#offersFeature"> <rdfs:range rdf:resource="#Feature"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#requiresFeature"> <rdfs:range rdf:resource="#Feature"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:about="#interface">
  <rdfs:range  rdf:resource="#Interface"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#interfaceFault">
  <rdfs:range  rdf:resource="#InterfaceFault"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#interfaceFaultReference">
  <rdfs:range  rdf:resource="#InterfaceFaultReference"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#interfaceMessageReference">
  <rdfs:range  rdf:resource="#InterfaceMessageReference"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#binds">
  <rdfs:comment>
    points from a binding component (or any sub-component) to the respective
    interface component (or sub-component)
  </rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#operationStyle">
  <rdfs:domain rdf:resource="#InterfaceOperation"/>
  <rdfs:range  rdf:resource="#OperationStyle"/>
  <rdfs:comment>
    points to one style this operation conforms to (can be used multiple times
    to point to multiple styles)
  </rdfs:comment>
</owl:ObjectProperty>

<owl:Class rdf:about="#OperationStyle">
</owl:Class>

<owl:ObjectProperty rdf:about="#interfaceOperation">
  <rdfs:range  rdf:resource="#InterfaceOperation"/>
  <rdfs:comment>
    used on interface to link to an operation
  </rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#messageContentModel">
  <rdfs:range  rdf:resource="#MessageContentModel"/>
</owl:ObjectProperty>

<owl:Class rdf:about="#MessageContentModel">
  <owl:oneOf rdf:parseType="Collection">
      <wsdl:MessageContentModel rdf:about="#AnyContent"/>
      <wsdl:MessageContentModel rdf:about="#NoContent"/>
      <wsdl:MessageContentModel rdf:about="#ElementContent"/>
      <wsdl:MessageContentModel rdf:about="#OtherContent"/>
  </owl:oneOf>
</owl:Class>

<owl:ObjectProperty rdf:about="#messageExchangePattern">
  <rdfs:range  rdf:resource="#MessageExchangePattern"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="#messageLabel">
  <rdfs:range  rdf:resource="#MessageLabel"/>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="#propertyValue"> <rdfs:range rdf:resource="#PropertyValue"/> </owl:ObjectProperty> <owl:ObjectProperty rdf:about="#property"> <rdfs:range rdf:resource="#Property"/> </owl:ObjectProperty> <owl:DatatypeProperty rdf:about="#propertyActualValue"> <rdfs:domain rdf:resource="#PropertyValue"/> <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/> </owl:DatatypeProperty> <owl:ObjectProperty rdf:about="#propertyValueType"> <rdfs:domain rdf:resource="#PropertyValue"/> <rdfs:range rdf:resource="#QName"/> </owl:ObjectProperty> <owl:ObjectPropertyrdf:about="#service">
  <rdfs:range  rdf:resource="#Service"/>
</owl:ObjectProperty>


 <owl:DatatypeProperty rdf:about="#documentation"> <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/> </owl:DatatypeProperty> <owl:DatatypeProperty rdf:about="#extensionElement"> <rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"/> </owl:DatatypeProperty> <owl:ObjectProperty rdf:about="#extensionAttribute"> <rdfs:range rdf:resource="#ExtensionAttribute"/> </owl:ObjectProperty> <owl:Class rdf:about="#ExtensionAttribute"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#attributeName"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#value"/> <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> <rdfs:comment> Represents an extension attribute with a name and a value. The value should be a literal. This should only be used for extension attributes that aren't understood by the generator of the RDF model, otherwise the extension should define how the attribute shows in the RDF model. </rdfs:comment> </owl:Class> <owl:ObjectProperty rdf:about="#attributeName"> <rdfs:range rdf:resource="#QName"/> </owl:ObjectProperty><!-- part 2: message exchange patterns -->

<owl:Class rdf:about="#NoFaults">
  <rdfs:subClassOf rdf:resource="#MessageExchangePattern" />
  <owl:disjointWith rdf:resource="#FaultReplacesMessage"/>
  <owl:disjointWith rdf:resource="#MessageTriggersFault"/>
</owl:Class>

<owl:Class rdf:about="#FaultReplacesMessage">
  <rdfs:subClassOf rdf:resource="#MessageExchangePattern" />
  <owl:disjointWith rdf:resource="#MessageTriggersFault"/>
</owl:Class>

<owl:Class rdf:about="#MessageTriggersFault">
  <rdfs:subClassOf rdf:resource="#MessageExchangePattern" />
</owl:Class>

<wsdl:NoFaults  rdf:about="http://www.w3.org/2006/01/wsdl/in-only">rdf:about="http://www.w3.org/ns/wsdl/in-only">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/in-only#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-only#In"/>
  </wsdl:definesMessageLabel>
</wsdl:NoFaults>

<wsdl:NoFaults  rdf:about="http://www.w3.org/2006/01/wsdl/out-only">rdf:about="http://www.w3.org/ns/wsdl/out-only">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/out-only#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-only#Out"/>
  </wsdl:definesMessageLabel>
</wsdl:NoFaults>

<wsdl:MessageTriggersFault  rdf:about="http://www.w3.org/2006/01/wsdl/robust-in-only">rdf:about="http://www.w3.org/ns/wsdl/robust-in-only">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/robust-in-only#In"/>rdf:about="http://www.w3.org/ns/wsdl/robust-in-only#In"/>
  </wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>

<wsdl:MessageTriggersFault  rdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out">rdf:about="http://www.w3.org/ns/wsdl/in-opt-out">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-opt-out#In"/>
  </wsdl:definesMessageLabel>
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/in-opt-out#Out"/>rdf:about="http://www.w3.org/ns/wsdl/in-opt-out#Out"/>
  </wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>

<wsdl:MessageTriggersFault  rdf:about="http://www.w3.org/2006/01/wsdl/robust-out-only">rdf:about="http://www.w3.org/ns/wsdl/robust-out-only">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/robust-out-only#Out"/>rdf:about="http://www.w3.org/ns/wsdl/robust-out-only#Out"/>
  </wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>

<wsdl:MessageTriggersFault  rdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in">rdf:about="http://www.w3.org/ns/wsdl/out-opt-in">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-opt-in#Out"/>
  </wsdl:definesMessageLabel>
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/out-opt-in#In"/>rdf:about="http://www.w3.org/ns/wsdl/out-opt-in#In"/>
  </wsdl:definesMessageLabel>
</wsdl:MessageTriggersFault>

<wsdl:FaultReplacesMessage  rdf:about="http://www.w3.org/2006/01/wsdl/in-out">rdf:about="http://www.w3.org/ns/wsdl/in-out">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/in-out#In"/>rdf:about="http://www.w3.org/ns/wsdl/in-out#In"/>
  </wsdl:definesMessageLabel>
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/in-out#Out"/>rdf:about="http://www.w3.org/ns/wsdl/in-out#Out"/>
  </wsdl:definesMessageLabel>
</wsdl:FaultReplacesMessage>

<wsdl:FaultReplacesMessage  rdf:about="http://www.w3.org/2006/01/wsdl/out-in">rdf:about="http://www.w3.org/ns/wsdl/out-in">
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/out-in#Out"/>rdf:about="http://www.w3.org/ns/wsdl/out-in#Out"/>
  </wsdl:definesMessageLabel>
  <wsdl:definesMessageLabel>
    <wsdl:MessageLabel  rdf:about="http://www.w3.org/2006/01/wsdl/out-in#In"/>rdf:about="http://www.w3.org/ns/wsdl/out-in#In"/>
  </wsdl:definesMessageLabel>
</wsdl:FaultReplacesMessage>

<!-- part 2: safety -->

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl-extensions#SafeInteraction"> <rdfs:subClassOf rdf:resource="#InterfaceOperation" />rdf:about="http://www.w3.org/ns/wsdl-extensions#SafeInteraction">
  <rdfs:comment>
    Class  of all operations that are asserted to berepresenting safe interactions as defined in Web Architecture at W3C.
  </rdfs:comment>
</owl:Class>

<!-- part 2: operation styles -->

<wsdl:OperationStyle  rdf:about="http://www.w3.org/2006/01/wsdl/style/rpc">rdf:about="http://www.w3.org/ns/wsdl/style/rpc">
  <rdfs:comment>RPC operation style</rdfs:comment>
</wsdl:OperationStyle>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/rpc#signature">rdf:about="http://www.w3.org/ns/wsdl/rpc#signature">
  <rdfs:domain rdf:resource="#InterfaceOperation"/>
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/rpc#signatureType"/>rdf:resource="http://www.w3.org/ns/wsdl/rpc#signatureType"/>
  <rdfs:comment>todo - can we use the above URI for the datatype of this property?</rdfs:comment>
</owl:DatatypeProperty>

<wsdl:OperationStyle  rdf:about="http://www.w3.org/2006/01/wsdl/style/iri">rdf:about="http://www.w3.org/ns/wsdl/style/iri">
  <rdfs:comment>IRI operation style</rdfs:comment>
</wsdl:OperationStyle>

<wsdl:OperationStyle  rdf:about="http://www.w3.org/2006/01/wsdl/style/multipart">rdf:about="http://www.w3.org/ns/wsdl/style/multipart">
  <rdfs:comment>multipart operation style</rdfs:comment>
</wsdl:OperationStyle>



<!-- part 2: bindings -->

<!-- SOAP binding -->

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/soap">rdf:about="http://www.w3.org/ns/wsdl/soap">
  <rdfs:comment>WSDL 2 SOAP binding</rdfs:comment>
  <rdfs:subClassOf rdf:resource="#Binding"/>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty  rdf:resource="http://www.w3.org/2006/01/wsdl/soap#version"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#version"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty  rdf:resource="http://www.w3.org/2006/01/wsdl/soap#protocol"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#protocol"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#version">rdf:about="http://www.w3.org/ns/wsdl/soap#version">
  <rdfs:comment>
    indicates what version of SOAP is used by the binding, usually "1.2"
    todo - using string is fairly ugly, but can we invent URIs?
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#protocol">rdf:about="http://www.w3.org/ns/wsdl/soap#protocol">
  <rdfs:comment>
    indicates the underlying protocol used by a binding
    todo - protocol class and the known instances? ask the XMLP group
  </rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#faultCode">rdf:about="http://www.w3.org/ns/wsdl/soap#faultCode">
  <rdfs:comment>
    indicates the fault code of a binding fault
  </rdfs:comment>
  <rdfs:range  rdf:resource="#QName"/>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#faultSubcodes">rdf:about="http://www.w3.org/ns/wsdl/soap#faultSubcodes">
  <rdfs:comment>
    indicates the fault subcodes of a binding fault; there can be multiple subcodes
    todo - make the range  aan rdf:Seq (maybe of  QNamesQNames)
  </rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#soapMEP">rdf:about="http://www.w3.org/ns/wsdl/soap#soapMEP">
  <rdfs:comment>
    indicates the SOAP MEP this binding operation uses
  </rdfs:comment>
  <rdfs:range rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#defaultSoapMEP">rdf:about="http://www.w3.org/ns/wsdl/soap#defaultSoapMEP">
  <rdfs:comment>
    indicates the default SOAP MEP this binding's operations use
  </rdfs:comment>
  <rdfs:range rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</owl:ObjectProperty>

<owl:Class rdf:about="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs">
</owl:Class>

<rdf:Description rdf:about="http://www.w3.org/2003/05/soap/mep/request-response/">
  <rdf:type rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</rdf:Description>

<rdf:Description rdf:about="http://www.w3.org/2003/05/soap/mep/soap-response/">
  <rdf:type rdf:resource="http://www.w3.org/2006/02/soap12/abstractions#classOfMEPs"/>
</rdf:Description>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#action">rdf:about="http://www.w3.org/ns/wsdl/soap#action">
  <rdfs:comment>
    indicates the SOAP action this binding operation uses
  </rdfs:comment>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#offersSOAPModule">rdf:about="http://www.w3.org/ns/wsdl/soap#offersSOAPModule">
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPModule"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPModule"/>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#requiresSOAPModule">rdf:about="http://www.w3.org/ns/wsdl/soap#requiresSOAPModule">
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPModule"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPModule"/>
</owl:ObjectProperty>

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/soap#SOAPModule">rdf:about="http://www.w3.org/ns/wsdl/soap#SOAPModule">
  <rdfs:comment>
    a SOAP module; a WSDL 2 SOAP binding (and subcomponents) may use or
    require any number of modules
    todo - should this class be created by xmlp group?
  </rdfs:comment>
</owl:Class>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#offersHeader">rdf:about="http://www.w3.org/ns/wsdl/soap#offersHeader">
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock"/>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/soap#requiresHeader">rdf:about="http://www.w3.org/ns/wsdl/soap#requiresHeader">
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock"/>rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock"/>
</owl:ObjectProperty>

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock">rdf:about="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock">
  <rdfs:comment>
    a SOAP header
  </rdfs:comment>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#elementDeclaration"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/soap#MustUnderstandSOAPHeaderBlock">rdf:about="http://www.w3.org/ns/wsdl/soap#MustUnderstandSOAPHeaderBlock">
  <rdfs:subClassOf  rdf:resource="http://www.w3.org/2006/01/wsdl/soap#SOAPHeaderBlock"rdf:resource="http://www.w3.org/ns/wsdl/soap#SOAPHeaderBlock" />
  <rdfs:comment>
    a SOAP header that must be marked as mustUnderstand by the sender
  </rdfs:comment>
</owl:Class>

<!-- HTTP binding -->

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/http">rdf:about="http://www.w3.org/ns/wsdl/http">
  <rdfs:comment>WSDL 2 HTTP binding</rdfs:comment>
  <rdfs:subClassOf rdf:resource="#Binding"/>
</owl:Class>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#location">rdf:about="http://www.w3.org/ns/wsdl/http#location">
  <rdfs:comment>
    defines the location for an operation, relative to the address of the
    service; this is the only URI-valued property modeled as datatype
    property because the URI is not meant as pointer to a resource
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#anyURI"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#locationIgnoreUncited">rdf:about="http://www.w3.org/ns/wsdl/http#locationIgnoreUncited">
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#boolean"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#defaultMethod">rdf:about="http://www.w3.org/ns/wsdl/http#defaultMethod">
  <rdfs:comment>
    declares the default HTTP method used by this binding's operations
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#method">rdf:about="http://www.w3.org/ns/wsdl/http#method">
  <rdfs:comment>
    declares the HTTP method used by this operation
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#inputSerialization">rdf:about="http://www.w3.org/ns/wsdl/http#inputSerialization">
  <rdfs:comment>
    declares the media type of the input message of an operation
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#outputSerialization">rdf:about="http://www.w3.org/ns/wsdl/http#outputSerialization">
  <rdfs:comment>
    declares the media type of the output message of an operation
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#faultSerialization">rdf:about="http://www.w3.org/ns/wsdl/http#faultSerialization">
  <rdfs:comment>
    declares the media type of the fault messages of an operation
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#defaultQueryParameterSeparator">rdf:about="http://www.w3.org/ns/wsdl/http#defaultQueryParameterSeparator">
  <rdfs:comment>
    declares the default character to be used as query parameter separator by this binding's operations
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#queryParameterSeparator">rdf:about="http://www.w3.org/ns/wsdl/http#queryParameterSeparator">
  <rdfs:comment>
    declares the character to be used as query parameter separator by an operation
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#headerName">rdf:about="http://www.w3.org/ns/wsdl/http#headerName">
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#requiresHeader">rdf:about="http://www.w3.org/ns/wsdl/http#requiresHeader">
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/http#HTTPHeader"/>rdf:resource="http://www.w3.org/ns/wsdl/http#HTTPHeader"/>
</owl:ObjectProperty>

<owl:ObjectProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#offersHeader">rdf:about="http://www.w3.org/ns/wsdl/http#offersHeader">
  <rdfs:range   rdf:resource="http://www.w3.org/2006/01/wsdl/http#HTTPHeader"/>rdf:resource="http://www.w3.org/ns/wsdl/http#HTTPHeader"/>
</owl:ObjectProperty>

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/http#HTTPHeader">rdf:about="http://www.w3.org/ns/wsdl/http#HTTPHeader">
  <rdfs:comment>
    an HTTP header
  </rdfs:comment>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#typeDefinition"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty  rdf:resource="http://www.w3.org/2006/01/wsdl/http#headerName"/>rdf:resource="http://www.w3.org/ns/wsdl/http#headerName"/>
      <owl:cardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:cardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#errorCode">rdf:about="http://www.w3.org/ns/wsdl/http#errorCode">
  <rdfs:comment>
    declares the error status code that a fault will return
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#int"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty
 rdf:about="http://www.w3.org/2006/01/wsdl/http#defaultTransferCoding">rdf:about="http://www.w3.org/ns/wsdl/http#defaultContentEncoding">
  <rdfs:comment>
    declares the default  transfer codingcontent encoding to be used by this binding's operation messages
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#transferCoding">rdf:about="http://www.w3.org/ns/wsdl/http#contentEncoding">
  <rdfs:comment>
    declares the  transfer codingcontent encoding to be used by operation messages
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:Class  rdf:about="http://www.w3.org/2006/01/wsdl/http#HTTPBindingWithCookies">rdf:about="http://www.w3.org/ns/wsdl/http#HTTPBindingWithCookies">
  <rdfs:comment>WSDL 2 HTTP binding with cookies</rdfs:comment>
  <rdfs:subClassOf  rdf:resource="http://www.w3.org/2006/01/wsdl/http"/>rdf:resource="http://www.w3.org/ns/wsdl/http"/>
</owl:Class>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#authenticationScheme">rdf:about="http://www.w3.org/ns/wsdl/http#authenticationScheme">
  <rdfs:comment>
    declares the authentication scheme used by an endpoint, by default "none"
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty  rdf:about="http://www.w3.org/2006/01/wsdl/http#authenticationRealm">rdf:about="http://www.w3.org/ns/wsdl/http#authenticationRealm">
  <rdfs:comment>
    declares the authentication realm used by an endpoint
  </rdfs:comment>
  <rdfs:range  rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>


</rdf:RDF>