The keywords “MUST”, “MUST NOT”, “EQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119 .

Namespace names of the general form:

represent application or context-dependent URIs .

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 ).

This section describes the terms and concepts introduced in Part 1 of the WSDL Version 2.0 specification (this document).

This specification refers to properties in the XML Information Set . Such properties are denoted by square brackets, e.g. [children], [attributes].

This specification defines and refers to properties in the WSDL 2.0 Component Model . Such properties are denoted by curly brackets, e.g. {name}, {interfaces}.

This specification uses a consistent naming convention for component model properties that refer to components. If a property refers to a required or optional component, then the property name is the same as the component name. If a property refers to a set of components, then the property name is the pluralized form of the component name.

Z Notation was used in the development of this specification. Z Notation is a formal specification language that is based on standard mathematical notation. The Z Notation for this specification has been verified using the Fuzz 2000 type-checker .

Since Z Notation is not widely known, it is not included the normative version of this specification. However, it is included in a non-normative version which allows to dynamically hide and show the Z Notation. Browsers correctly display the mathematical Unicode characters, provided that the required fonts are installed. Mathematical fonts for Mozilla Firefox can be downloaded from the Mozilla Web site.

The Z Notation was used to improve the quality of the normative text that defines the Component Model, and to help ensure that the test suite covered all important rules implied by the Component Model. However, the Z Notation is non-normative, so any conflict between it and the normative text is an error in the Z Notation. Readers and implementors may nevertheless find the Z Notation useful in cases where the normative text is unclear.

There are two elements of Z Notation syntax that conflict with the notational conventions described in the preceeding sections. In Z Notation, square brackets are used to introduce basic sets, e.g. [ID], which conflicts with the use of square brackets to denote XML Information Set properties . Also, in Z Notation, curly brackets are used to denote set display and set comprehension, e.g. {1, 2, 3}, which conflicts with the use of curly brackets to denote WSDL 2.0 Component Model properties . However, the intended meaning of square and curly brackets should be clear from their context and this minor notational conflict should not cause any confusion.

Pseudo-schemas are provided for each component, before the description of the component. They use BNF-style conventions for attributes and elements: ? denotes optionality (i.e. zero or one occurrences), * denotes zero or more occurrences, + one or more occurrences, [ and ] are used to form groups, and | represents choice. Attributes are conventionally assigned a value which corresponds to their type, as defined in the normative schema.

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

WSDL 2.0 components are interfaces, bindings and services. Type system components are element declarations and type definitions.

Interface, Binding, Service, Element Declaration, and Type Definition components are directly contained in the Description component and are referred to as top-level components. The top-level WSDL 2.0 components contain other components, e.g. Interface Operation and Endpoint, which are referred to as nested components. Nested components may contain other nested components. The component that contains a nested component is referred to as the parent of the nested components. Nested components have a {parent} property that is a reference to their parent component.

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 2.0; see . In the case where they define information equivalent to that of a XML Schema global element declaration, they can be treated as if they were such a declaration.

This specification does not define the behavior of a WSDL 2.0 document that uses multiple schema languages for describing type system components simultaneously.

The properties of the Description component are as follows:

The set of top-level components contained in the Description component associated with an initial WSDL 2.0 document consists of the components defined in the initial document and the components associated with the documents that the initial document includes or imports. The component model makes no distinction between the components that are defined in the initial document versus those that are defined in the included or imported documents. However, any WSDL 2.0 document that contains component definitions that refer by QName to WSDL 2.0 components that belong to a different namespace MUST contain a ws:import element information item for that namespace (see ). Furthermore, all QName references, whether to the same or to different namespaces MUST resolve to components (see ).

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

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

The components directly defined or included within a Description 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 value of the targetNamespace attribute information item SHOULD be a dereferenceable URI. It SHOULD resolve to a human or machine processable document that directly or indirectly defines the intended semantics of those components. It MAY resolve to a WSDL 2.0 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 2.0 documents needed for that service description. This approach enables the WSDL 2.0 component designators' fragment identifiers to be properly resolvable.

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

Each WSDL 2.0 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.

The description element information item has the following Infoset properties:

The mapping from the XML Representation of the description element information item (see ) to the properties of the Description component (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.

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. The set of operations available in an interface includes all the operations defined by the interfaces it extends, along with any operations it directly defines. The operations directly defined on an interface are referred to as the declared operations of the interface. 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 description container, the {name} property MUST be unique.

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

The mapping from the XML Representation of the interface element information item (see ) to the properties of the Interface component (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 Interface 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 {interface faults} property of an Interface component, the {name} property must be unique.

Interface Fault components are uniquely identified by the the QName of the enclosing Interface component and QName of the Interface Fault component itself.

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} property, 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} properties but are not equivalent.

Note that, due to the above rules, if two interfaces that have the same value for the namespace name of their {name} 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 from the XML Representation of the fault element information item (see ) to the properties of the Interface Fault component (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 of (ordinary and fault) messages exchanged between the service and the other parties involved in the interaction. 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 {inteface message references} and {interface 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 {interface operations} property of an Interface component, the {name} property MUST be unique.

Interface Operation components are uniquely identified by the the QName of the enclosing Interface component and QName of the Interface Operation component itself.

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} property, 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} property but are not equivalent.

Note that, due to the above rules, if two interfaces that have the same value for the namespace name of their {name} 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.

More than one Interface Fault Reference component in the {interface fault references} property of an Interface Operation component may refer to the same message label. In that case, the listed fault types define alternative fault messages. This allows one to indicate that there is more than one type of fault that is related to that message.

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

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

A Interface Message Reference component associates a defined element with a message exchanged in an operation. By default, the element is defined in 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 an Interface Message Reference component is to associate an actual message element (XML element declaration or some other declaration (see )) 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 element assignment made by the Interface Message Reference component.

The properties of the Interface 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 Interface Message Reference Component (along with extensibility attributes to its XML representation) to allow associating such message types with the message reference.

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

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

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

An Interface 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 an Interface 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.

The properties of the Interface Fault Reference component are as follows:

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

The mapping from the XML Representation of the message reference element information item (see ) to the properties of the Interface Fault Reference component (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 2.0 imposes 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 2.0 description indicates that the service supports the feature and may require a client that interacts with the service to use that feature. Each Feature is identified by its URI.

WSDL 2.0's feature concept is derived from SOAP 1.2's abstract feature concept (). Thus, by definition, every SOAP 1.2 abstract feature is also a WSDL 2.0 feature and does not have to be declared as such.

The properties of the Feature component are as follows:

The {uri} property of a Feature component MUST be unique within the {features} property of an Interface, Interface Fault, Interface Operation, Interface Message Reference, Fault Reference, Binding, Binding Fault, Binding Operation, Binding Message Reference, Binding Fault Reference, Service, or Endpoint component.

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

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

A “property” in the Features and Properties architecture represents a named runtime value which affects the behavior 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 2.0 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:

The {uri} property of a Property component MUST be unique within the {properties} property of an Interface, Interface Fault, Interface Operation, Interface Message Reference, Fault Reference, Binding, Binding Fault, Binding Operation, Binding Message Reference, Binding Fault Reference, Service, or Endpoint component.

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.

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

The mapping from the XML Representation of the property element information item (see ) to the properties of the Property component (see ) is as described in .

A Binding component describes a concrete message format and transmission protocol which may be used to define an endpoint (see ). That is, a Binding component defines the implementation details necessary to access the service.

Binding components can be used to describe such information in a re-usable manner for any interface or specifically for a given interface. Furthermore, binding information MAY be specified on a per-operation basis (see ) within an interface in addition to across all operations of an interface.

If a Binding component specifies any operation-specific binding details (by including Binding Operation components) or any fault binding details (by including Binding Fault components) then it MUST specify an interface the Binding component applies to, so as to indicate which interface the operations come from.

Conversely, a Binding component which omits any operation-specific binding details and any fault binding details MAY omit specifying an interface. Binding components that do not specify an interface MAY be used to specify operation-independent binding details for Service components with different interfaces. That is, such Binding components are reusable across one or more interfaces.

No concrete binding details are given in this specification. The companion specification, WSDL (Version 2.0): Adjuncts defines such bindings for SOAP 1.2 and HTTP . Other specifications MAY define additional binding details. Such specifications are expected to annotate the Binding component (and its sub-components) with additional properties and specify the mapping from the XML representation to those properties.

A Binding component which defines bindings for an Interface component MUST define bindings for all the operations of that Interface component. The bindings may occur via defaulting rules which allow one to specify default bindings for all operations (see, for example ) or by directly listing each Operation component of the Interface component and defining bindings for them. Thus, it is an error for a Binding component to not define bindings for all the Operation components of the Interface component for which the Binding component purportedly defines bindings for.

Bindings are named constructs and can be referred to by QName (see ). For instance, Endpoint components refer to bindings in this way.

The properties of the Binding component are as follows:

For each Binding component in the {bindings} property of a description container, the {name} property MUST be unique.

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

The mapping from the XML Representation of the binding element information item (see ) to the properties of the Binding component (see ) is as described in .

A Binding Fault component describes a concrete binding of a particular fault within an interface to a particular concrete message format. A particular fault of an interface is uniquely identified by its {name} property.

Note that the fault does not occur by itself - it occurs as part of a message exchange as defined by an Interface Operation component (and its binding counterpart the Binding Operation component). Thus, the fault binding information specified in a Binding Fault component describes how faults that occur within a message exchange of an operation will be formatted and carried in the transport.

The properties of the Binding Fault component are as follows:

For each Binding Fault component in the {binding faults} property of a Binding component, the {interace fault} property MUST be unique. That is, one cannot define multiple bindings for the same fault within a given Binding component.

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

The mapping from the XML Representation of the fault element information item (see ) to the properties of the Binding Fault component (see ) is as described in .

The Binding Operation component describes the concrete message format(s) and protocol interaction(s) associated with a particular interface operation for a given endpoint. A particular operation of an interface is uniquely identified by its {name} property.

The properties of the Binding Operation component are as follows:

For each Binding Operation component in the {binding operations} property of a Binding component, the {interface operation} property MUST be unique. That is, one cannot define multiple bindings for the same operation within a given Binding component.

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

The mapping from the XML Representation of the operation element information item (see ) to the properties of the Binding Operation component (see ) is as described in .

A Binding Message Reference component describes a concrete binding of a particular message participating in an operation to a particular concrete message format.

The properties of the Binding Message Reference component are as follows:

For each Binding Message Reference component in the {binding message references} property of a Binding Operation component, the {interface message reference} property MUST be unique. That is, the same message cannot be bound twice within the same operation.

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

The mapping from the XML Representation of the binding element information item (see ) to the properties of the Binding Message Reference component (see ) is as described in .

A Binding Fault Reference component describes a concrete binding of a particular fault participating in an operation to a particular concrete message format.

The properties of the Binding Fault Reference component are as follows:

For each Binding Fault Reference component in the {binding fault references} property of a Binding Operation component, the {interface fault reference} property MUST be unique. That is, the same fault cannot be bound twice within the same operation.

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

The mapping from the XML Representation of the binding element information item (see ) to the properties of the Binding Fault Reference component (see ) is as described in .

A Service component describes a set of endpoints (see ) at which a particular deployed implementation of the service is provided. The endpoints thus are in effect alternate places at which the service is provided.

Services are named constructs and can be referred to by QName (see ).

The properties of the Service component are as follows:

For each Service component in the {services} property of a description container, the {name} property MUST be unique.

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

The mapping from the XML Representation of the service element information item (see ) to the properties of the Service component (see ) is as described in .

An Endpoint component defines the particulars of a specific endpoint at which a given service is available.

Endpoint components are local to a given Service component; they cannot be referred to by QName (see ).

The properties of the Endpoint component are as follows:

For each Endpoint component in the {endpoints} property of a Service component, the {binding} property (see ) MUST either be a Binding component with an unspecified {interface} property (see or a Binding component with an {interface} property equal to the {interface} property of the Service component.

For each Endpoint component in the {endpoints} property of a Service component, the {name} property MUST be unique.

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

The mapping from the XML Representation of the endpoint element information item (see ) to the properties of the Endpoint component (see ) is as described in .

Importing an XML Schema uses the syntax and semantics of the xs:import mechanism defined by XML Schema ,, with some additional restrictions. The schema components defined in the imported namespace are available for reference by QName (see ). Note that only components in the imported namespace are available for reference in the WSDL 2.0 document.

A child element information item of the types element information item is defined with the Infoset properties as follows:

Inlining an XML schema uses the existing top-level xs:schema element information item defined by XML Schema . It may be viewed as simply cutting and pasting an existing schema document to a location inside the types element information item.

The schema components defined and declared in the inlined schema document are available to WSDL 2.0 for reference by QName (see ). Note that only components defined and declared in the schema itself and components included by it via xs:include are available to WSDL 2.0. Specifically components that the schema imports via xs:import are NOT available to WSDL 2.0.

Similarly, components defined in an inlined XML schema are NOT automatically made available to a WSDL 2.0 description that imported (using wsdl:import) the description that inlines the schema (see for more details). For this reason, it is recommended that XML schema documents intended to be shared across several WSDL 2.0 descriptions be placed in separate documents and imported using xs:import, rather than inlined inside a WSDL 2.0 document.

Inside an inlined XML schema, the xs:import and xs:include element information items MAY be used to refer to other XML schemas inlined in the same or other WSDL 2.0 document, provided that an appropriate value, such as a fragment identifier (see 4.3.1) is specified for their schemaLocation attribute information items. For xs:import, the schemaLocation attribute is not required so long as the namespace has been resolved in the current component model. The semantics of such element information items are governed solely by the XML Schema specification .

Note: It is NOT an error to import two or more schemas from the same targetNamespace. It is the responsibility of the underlying schema processor to sort out a coherent set of schema components.

The xs:schema element information item has the following Infoset properties:

Whether inlined or imported, the element declarations present in a schema may be referenced from an Interface Message Reference or Interface Fault component. Similarly, regardless of whether they are inlined or imported, the type definitions present in a schema may be referenced from a Property component.

A named, global xs:element declaration may be referenced from the element attribute information item of an input, output or fault element information item. The QName is constructed from the targetNamespace of the schema and the value of the name attribute information item of the xs:element element information item. An element attribute information item MUST NOT refer to a global xs:simpleType or xs:complexType definition.

A named, global xs:simpleType or xs:complexTypedeclaration may be referenced from the constraint attribute information item of property element information item. The QName is constructed from the targetNamespace of the schema and the value of the name attribute information item of the xs:simpleType or xs:complexType element information item. A constraint attribute information item MUST NOT refer to a global xs:element definition.

The location attribute information item has the following Infoset properties:

A location attribute information item is of type xs:anyURI. Its actual value is the location of some information about the namespace identified by the targetNamespace attribute information item of the containing description element information item.

It is an error if the URI indicated by location does not resolve to a WSDL 2.0 document.

The actual value of the targetNamespace attribute information item of the included WSDL 2.0 document MUST match the actual value of the targetNamespace attribute information item of the description element information item which is the [parent] of the include element information item.

The namespace attribute information item has the following Infoset properties:

The namespace attribute information item is of type xs:anyURI. Its actual value indicates that the containing WSDL 2.0 document MAY contain qualified references to WSDL 2.0 definitions in that namespace (via one or more prefixes declared with namespace declarations in the normal way). This value MUST NOT match the actual value of targetNamespace attribute information item in the enclosing WSDL 2.0 document. If the location attribute in the import element information item references a WSDL 2.0 document, then the actual value of the namespace attribute information item MUST be identical to the actual value of the targetNamespace attribute information item in the referenced WSDL 2.0 document.

The location attribute information item has the following Infoset properties:

The location attribute information item is of type xs:anyURI. The actual value of the location attribute information item, if present on a WSDL 2.0 import element information item, gives a hint as to where a serialization of a WSDL 2.0 document with definitions for the imported namespace may be found.

The location attribute information item is optional. This allows WSDL 2.0 components to be constructed from information other than serialized XML 1.0 or a WSDL 2.0 document. It also allows the development of WSDL 2.0 processors that have a prior (i.e., built-in) knowledge of certain namespaces.

Extension elements can be marked as mandatory by annotating them with a wsdl:required attribute information item (see ) with a value of true. A mandatory extension is an extension that MAY change the meaning of the element to which it is attached, such that the meaning of that element is no longer governed by this specification. Instead, the meaning of an element containing a mandatory extension is governed by the meaning of that extension. Thus, the definition of the element's meaning is delegated to the specification that defines the extension.

An extension that is NOT marked as mandatory MUST NOT invalidate the meaning of any part of the WSDL 2.0 document. Thus, a NON-mandatory extension merely provides additional description of capabilities of the service. This specification does not provide a mechanism to mark extension attributes as being required. Therefore, all extension attributes are NON-mandatory.

If a WSDL 2.0 document declares an extension, Feature or Property as optional (i.e., NON-mandatory), then the Web service MUST NOT assume that the client supports that extension, Feature or Property, unless the Web service knows (through some other means) that the client has in fact elected to engage and support that extension, Feature or Property.

On the other hand, a client MAY engage an extension, Feature or Property that is declared as optional in the WSDL 2.0 document. Therefore, the Web service MUST support every extension, Feature or Property that is declared as optional in the WSDL 2.0 document, in addition to supporting every extension, Feature or Property that is declared as mandatory.

WSDL 2.0 provides a global attribute information item with the following Infoset properties:

The type of the required attribute information item is xs:boolean.