At the abstract level, the Definitions component is just a container for two categories of components; WSDL components and type system components.

WSDL components are interfaces, bindings and services.

Type system components describe the constraints on a message's content. By default, these constraints are expressed in terms of the , i.e. they define the [local name], [namespace name], [children] and [attributes] properties of an element information item. Type systems based upon other data models are generally accommodated by extensions to WSDL; see . In the case where they define information equivalent to that of a XML Schema global element declaration, they can more simply be treated as if they were such a declaration.

The properties of the Definitions component are as follows:

The set of interfaces/binding/services/etc. available in the Definitions component include those that are defined within the component itself and those that are imported and/or included. Note that at the component model level, there is no distinction between directly defined components vs. imported/included components.

The components directly defined within a single Definitions component are said to belong to the same target namespace. The target namespace therefore groups a set of related component definitions and represents an unambiguous name for the intended semantics of the collection of components. The target namespace URI SHOULD point to a human or machine processable document that directly or indirectly defines the intended semantics of those components.

Note that it is RECOMMENDED that the value of the targetNamespace attribute information item SHOULD be a dereferencible URI and that it resolve to a WSDL document which provides service description information for that namespace.

If a service description is split into multiple documents (which may be combined as needed via ), then the targetNamespace attribute information item SHOULD resolve to a master document which includes all the WSDL documents needed for that service description. This approach enables the WSDL component designators' fragment identifiers to be properly resolvable.

Imported components have different target namespace values from the Definitions component that is importing them. Thus importing is the mechanism to use components from one namespace in another set of definitions.

Each WSDL or type system component MUST be uniquely identified by its qualified name. That is, if two distinct components of the same kind (Interface, Binding etc.) are in the same target namespace, then their QNames MUST be unique. However, different kinds of components (e.g., an Interface component and a Binding component) MAY have the same QName. Thus, QNames of components must be unique within the space of those components in a given target namespace.

In addition to WSDL components and type system components, additional extension components MAY be added via extensibility . Further, additional properties to WSDL and type system components MAY also be added via extensibility.

WSDL definitions are represented in XML by one or more WSDL Information Sets (Infosets), that is one or more definitions element information items. A WSDL Infoset contains representations for a collection of WSDL components which share a common target namespace. A WSDL Infoset which contains one or more import element information items corresponds to a collection with components drawn from multiple target namespaces.

The targetNamespace URI MUST be an absolute URI (see ).

The definitions element information item has the following Infoset properties:

The mapping between the properties of the Definitions component (see ) and the XML Representation of the definitions element information item (see ) is described in .

An Interface component describes sequences of messages that a service sends and/or receives. It does this by grouping related messages into operations. An operation is a sequence of input and output messages, and an interface is a set of operations. Thus, an interface defines the design of the application.

An interface can optionally extend one or more other interfaces. To avoid circular definitions, an interface MUST NOT appear as an element of the set of interfaces it extends, either directly or indirectly. An interface contains all the operations defined by the interfaces it extends, along with any operations it directly defines. In the process, operation components that are equivalent per are treated as one. The interface extension mechanism behaves in a similar way for all other components that can be defined inside an interface, namely Interface Fault, Feature and Property components.

Interfaces are named constructs and can be referred to by QName (see ). For instance, Binding components refer to interfaces in this way.

The properties of the Interface component are as follows:

For each Interface component in the {interfaces} property of a definitions container, the combination of {name} and {target namespace} properties MUST be unique.

Additionally, an Interface component MUST satisfy the Operation Name Mapping requirement, as defined below. This requirement is intended to ensure that a received message can be uniquely mapped to a corresponding wsdl:operation.

The XML representation for an Interface component is an element information item with the following Infoset properties:

The mapping between the properties of the Interface component (see ) and the XML Representation of the interface element information item (see ) is as described in .

Note that, per , the Interface components in the {extended interfaces} property of a given Interface component MUST NOT contain that Interface component in any of their {extended interfaces} properties, that is to say, recursive extension of interfaces is disallowed.

A fault is an event that occurs during the execution of a message exchange that disrupts the normal flow of messages.

A fault is typically raised when a party is unable to communicate an error condition inside the normal message flow, or a party wishes to terminate a message exchange. A fault message may be used to communicate out of band information such as the reason for the error, the origin of the fault, as well as other informal diagnostics such as a program stack trace.

An Interface Fault component describes a fault that MAY occur during invocation of an operation of the interface. The Interface Fault component declares an abstract fault by naming it and indicating the contents of the fault message. When and how the fault message flows is indicated by the Interface Operation component .

The Interface Fault component provides a clear mechanism to name and describe the set of faults an interface may generate. This allows operations to easily identify the individual faults they may generate by name. This mechanism allows the ready identification of the same fault occurring across multiple operations and referenced in multiple bindings as well as reducing duplication of description for an individual fault.

Note that faults other than the ones described in the Interface component can also be generated at run-time, i.e. faults are an open set.

The properties of the Interface Fault component are as follows:

If a type system NOT based on the XML Infoset is in use (as considered in ) then additional properties would need to be added to the Fault Component (along with extensibility attributes to its XML representation) to allow associating such message types with the message reference.

For each Interface Fault component in the {faults} property of an Interface component, the combination of {name} and {target namespace} properties must be unique.

Interface Fault components are local to Interface components; they cannot be referred to by QName, despite having both {name} and {target namespace} properties. That is, two Interface components sharing the same {target namespace} property but with different {name} properties MAY contain Interface Fault components which share the same {name} property. Thus, the {name} and {target namespace} properties of the Interface Fault components are not sufficient to form the unique identity of an Interface Fault component. To uniquely identify an Interface Fault component one must first identify the Interface component (by QName) and then identify the Interface Fault within that Interface component (by a further QName).

In cases where, due to an interface extending one or more other interfaces, two or more Interface Faults components have the same value for their {name} and {target namespace} properties, then the component models of those Interface Fault components MUST be equivalent (see ). If the Interface Fault components are equivalent then they are considered to collapse into a single component. It is an error if two Interface Fault components have the same value for their {name} and {target namespace} properties but are not equivalent.

Note that, due to the above rules, if two interfaces that have the same value for their {target namespace} property also have one or more faults that have the same value for their {name} property then those two interfaces cannot both form part of the derivation chain of a derived interface unless those faults are the same fault.

The XML representation for an Interface Fault component is an element information item with the following Infoset properties:

The mapping between the properties of the Interface Fault component (see ) and the XML Representation of the fault element information item (see ) is as described in .

An Interface Operation component describes an operation that a given interface supports. An operation is an interaction with the service consisting of a set (ordinary and fault) messages exchanged between the service and the other roles involved in the interaction, in particular the service requester. The sequencing and cardinality of the messages involved in a particular interaction is governed by the message exchange pattern used by the operation (see {message exchange pattern} property).

A message exchange pattern defines placeholders for messages, the participants in the pattern (i.e., the sources and sinks of the messages), and the cardinality and sequencing of messages exchanged by the participants. The message placeholders are associated with specific message types by the operation that uses the pattern by means of message and fault references (see {message references} and {fault references} properties). The service whose operation is using the pattern becomes one of the participants of the pattern. This specification does not define a machine understandable language for defining message exchange patterns, nor does it define any specific patterns. The companion specification, defines a set of such patterns and defines identifying URIs any of which MAY be used as the value of the {message exchange pattern} property.

The properties of the Interface Operation component are as follows:

For each Interface Operation component in the {operations} property of an Interface component, the combination of {name} and {target namespace} properties MUST be unique.

Interface Operation components are local to Interface components; they cannot be referred to by QName, despite having both {name} and {target namespace} properties. That is, two Interface components sharing the same {target namespace} property but with different {name} properties MAY contain Interface Operation components which share the same {name} property. Thus, the {name} and {target namespace} properties of the Interface Operation components are not sufficient to uniquely identify an Interface Operation component. In order to uniquely identify an Interface Operation component, one must first identify the Interface component (by QName) and then identify the Interface Operation within that Interface component (by a further QName).

In cases where, due to an interface extending one or more other interfaces, two or more Interface Operation components have the same value for their {name} and {target namespace} properties, then the component models of those Interface Operation components MUST be equivalent (see ). If the Interface Operation components are equivalent then they are considered to collapse into a single component. It is an error if two Interface Operation components have the same value for their {name} and {target namespace} properties but are not equivalent.

Note that, due to the above rules, if two interfaces that have the same value for their {target namespace} property also have one or more operations that have the same value for their {name} property then those two interfaces cannot both form part of the derivation chain of a derived interface unless those operations are the same operation.

The RPC style is selected by assigning to an Interface Operation component's {style} property the value http://www.w3.org/2004/08/wsdl/style/rpc.

The RPC style MUST NOT be used for Interface Operation components whose {message exchange pattern} property has a value other than 'http://www.w3.org/2004/08/wsdl/in-only' or 'http://www.w3.org/2004/08/wsdl/in-out'.

When this value is used, the associated messages MUST conform to the rules below, described using XML Schema . Note that operations containing messages described by other type systems may also indicate use of the RPC style, as long as they are constructed in such a way as to follow these rules.

If the Interface Operation component uses a {message exchange pattern} for which there is no output element, such as 'http://www.w3.org/2004/08/wsdl/in-only', then the conditions stated below that refer to output elements MUST be considered to be implicitely satisfied.

The XML representation for an Interface Operation component is an element information item with the following Infoset properties:

The mapping between the properties of the Interface Operation component (see ) and the XML Representation of the operation element information item (see ) is as described in .

A Message Reference component associates a defined type with a message exchanged in an operation. By default, the type system is based upon the XML Infoset .

A message exchange pattern defines a set of placeholder messages that participate in the pattern and assigns them unique message labels within the pattern (e.g. 'In', 'Out'). The purpose of a Message Reference component is to associate an actual message type (XML element declaration or some other declaration (see ) for message content) with a message in the pattern, as identified by its message label. Later, when the message exchange pattern is instantiated, messages corresponding to that particular label will follow the type assignment made by the Message Reference component.

The properties of the Message Reference component are as follows:

If a type system not based upon the XML Infoset is in use (as considered in ) then additional properties would need to be added to the Message Reference Component (along with extensibility attributes to its XML representation) to allow associating such message types with the message reference.

For each Message Reference component in the {message references} property of an Interface Operation component, its {message label} property MUST be unique.

The XML representation for a Message Reference component is an element information item with the following Infoset properties:

The mapping between the properties of the Message Reference component (see ) and the XML Representation of the message reference element information item (see ) is as described in .

A Fault Reference component associates a defined type, specified by an Interface Fault component, to a fault message exchanged in an operation.

A message exchange pattern defines a set of placeholder messages that participate in the pattern and assigns them unique message labels within the pattern (e.g. 'In', 'Out'). The purpose of a Fault Reference component is to associate an actual message type (XML element declaration or some other declaration (see ) for message content, as specified by an Interface Fault component) with a fault message occurring in the pattern. In order to identify the fault message it describes, the Fault Reference component uses the message label of the message the fault is associated with as a key.

The companion specification defines two fault patterns that a given message exchange pattern may use. For the pattern fault-replaces-message, the message that the fault relates to identifies the message in place of which the declared fault message will occur. Thus, the fault message will travel in the same direction as the message it replaces in the pattern. For the pattern message-triggers-fault, the message that the fault relates to identifies the message after which the indicated fault may occur, in the opposite direction of the referred to message. That is, the fault message will travel in the opposite direction of the message it comes after in the pattern.

More than one Fault Reference component may refer to the same message label. This allows one to indicate that there is more than one type of fault that is related to that message.

The properties of the Fault Reference component are as follows:

The XML representation for a Fault Reference component is an element information item with the following Infoset properties:

The mapping between the properties of the Fault Reference component (see ) and the XML Representation of the message reference element information item (see ) is as described in .

A feature component describes an abstract piece of functionality typically associated with the exchange of messages between communicating parties. Although WSDL poses no constraints on the potential scope of such features, examples might include "reliability", "security", "correlation", and "routing". The presence of a feature component in a WSDL description indicates that the service supports the feature and may require a requester agent that interacts with the service to use that feature. Each Feature is identified by its URI.

The properties of the Feature component are as follows:

The XML representation for a Feature component is an element information item with the following Infoset properties:

The mapping between the properties of the Feature component (see ) and the XML Representation of the feature element information item (see ) is as described in .

A "property" in the Features and Properties architecture represents a named runtime value which affects the behaviour of some aspect of a Web service interaction, much like an environment variable. For example, a reliable messaging SOAP module may specify a property to control the number of retries in the case of network failure. WSDL documents may specify the value constraints for these properties by referring to a Schema type, or by specifying a particular value. Properties, and hence property values, can be shared amongst features/bindings/modules, and are named with URIs precisely to allow this type of sharing.

The properties of the Property component are as follows:

If a type system not based upon the XML Infoset is in use (as considered in ) then additional properties would need to be added to the Property Component (along with extensibility attributes to its XML representation) to allow using such a type system to describe values and constraints for properties.