W3C

Web Services Description Language (WSDL) Version 2.0 Part 1: Core Language

W3C Candidate Recommendation 6 January 2006
Non-normative version with Z Notation

Normative version at:
http://www.w3.org/TR/2006/CR-wsdl20-20060106
Latest version:
http://www.w3.org/TR/wsdl20
Previous versions:
http://www.w3.org/TR/2005/WD-wsdl20-20050803
Editors:
Roberto Chinnici, Sun Microsystems
Jean-Jacques Moreau, Canon
Arthur Ryman, IBM
Sanjiva Weerawarana, WSO2

This document is also available in these non-normative formats: XHTML with Z Notation, PDF, PDF with Z Notation, PostScript, XML, and plain text.

Copyright © 2006 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.

Abstract

This document describes the Web Services Description Language Version 2.0 (WSDL 2.0), an XML language for describing Web services. This specification defines the core language which can be used to describe Web services based on an abstract model of what the service offers. It also defines the conformance criteria for documents in this language.

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This is the W3C Candidate Recommendation of Web Services Description Language (WSDL) Version 2.0 Part 1: Core Language for review by W3C Members and other interested parties. It has been produced by the Web Services Description Working Group, which is part of the W3C Web Services Activity. The publication of this document signifies a call for implementations of this specification. This specification will remain a Candidate Recommendation at least until 15 March 2006.

This Working Draft addresses all the comments received during the second Last Call review period on the WSDL 2.0 drafts. The detailed disposition of the comments received can be found in the Last Call issues list. A diff-marked version against the previous version of this document is available. For a detailed list of changes since the last publication of this document, please refer to appendix E. Part 1 Change Log.

The Working Group plans to submit this specification for consideration as a W3C Proposed Recommendation if the following exit criteria have been met:

The sections 2.7 Feature and 2.8 Property in this specification, defining the feature and property components, are considered at risk. The Working Group may recommend to remove the components from the specification, depending on their use and the implementations.

Implementers are encouraged to provide feedback by 15 March 2006. Comments on this document are to be sent to the public public-ws-desc-comments@w3.org mailing list (public archive).

Issues about this document are recorded in the Candidate Recommendation issues list maintained by the Working Group. A list of formal objections against the set of WSDL 2.0 Working Drafts is also available.

Publication as a Candidate Recommendation does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

This document has been produced under the 24 January 2002 Current Patent Practice as amended by the W3C Patent Policy Transition Procedure. Patent disclosures relevant to this specification may be found on the Working Group's patent disclosure page. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) with respect to this specification should disclose the information in accordance with section 6 of the W3C Patent Policy.

Short Table of Contents

1. Introduction
2. Component Model
3. Types
4. Modularizing WSDL 2.0 descriptions
5. Documentation
6. Language Extensibility
7. Locating WSDL 2.0 Documents
8. Conformance
9. XML Syntax Summary (Non-Normative)
10. References
A. The application/wsdl+xml Media Type
B. Acknowledgements (Non-Normative)
C. IRI-References for WSDL 2.0 Components (Non-Normative)
D. Component Summary (Non-Normative)
E. Part 1 Change Log (Non-Normative)
F. Assertion Summary (Non-Normative)

Table of Contents

1. Introduction
    1.1 Web Service
    1.2 Document Conformance
    1.3 The Meaning of a Service Description
    1.4 Notational Conventions
        1.4.1 RFC 2119 Keywords
        1.4.2 RFC 3986 Namespaces
        1.4.3 XML Schema anyURI
        1.4.4 Prefixes and Namespaces Used in This Specification
        1.4.5 Terms Used in This Specification
        1.4.6 XML Information Set Properties
        1.4.7 WSDL 2.0 Component Model Properties
        1.4.8 Z Notation
        1.4.9 BNF Pseudo-Schemas
        1.4.10 Assertions
2. Component Model
    2.1 Description
        2.1.1 The Description Component
        2.1.2 XML Representation of Description Component
            2.1.2.1 targetNamespace attribute information item
        2.1.3 Mapping Description's XML Representation to Component Properties
    2.2 Interface
        2.2.1 The Interface Component
        2.2.2 XML Representation of Interface Component
            2.2.2.1 name attribute information item with interface [owner element]
            2.2.2.2 extends attribute information item
            2.2.2.3 styleDefault attribute information item
        2.2.3 Mapping Interface's XML Representation to Component Properties
    2.3 Interface Fault
        2.3.1 The Interface Fault Component
        2.3.2 XML Representation of Interface Fault Component
            2.3.2.1 name attribute information item with fault [owner element]
            2.3.2.2 element attribute information item with fault [owner element]
        2.3.3 Mapping Interface Fault's XML Representation to Component Properties
    2.4 Interface Operation
        2.4.1 The Interface Operation Component
            2.4.1.1 Message Exchange Pattern
            2.4.1.2 Operation Style
        2.4.2 XML Representation of Interface Operation Component
            2.4.2.1 name attribute information item with operation [owner element]
            2.4.2.2 pattern attribute information item with operation [owner element]
            2.4.2.3 style attribute information item with operation [owner element]
        2.4.3 Mapping Interface Operation's XML Representation to Component Properties
    2.5 Interface Message Reference
        2.5.1 The Interface Message Reference Component
        2.5.2 XML Representation of Interface Message Reference Component
            2.5.2.1 messageLabel attribute information item with input or output [owner element]
            2.5.2.2 element attribute information item with input or output [owner element]
        2.5.3 Mapping Interface Message Reference's XML Representation to Component Properties
    2.6 Interface Fault Reference
        2.6.1 The Interface Fault Reference Component
        2.6.2 XML Representation of Interface Fault Reference
            2.6.2.1 ref attribute information item with infault, or outfault [owner element]
            2.6.2.2 messageLabel attribute information item with infault, or outfault [owner element]
        2.6.3 Mapping Interface Fault Reference's XML Representation to Component Properties
    2.7 Feature
        2.7.1 The Feature Component
            2.7.1.1 Feature Composition Model
                2.7.1.1.1 Example of Feature Composition Model
        2.7.2 XML Representation of Feature Component
            2.7.2.1 ref attribute information item with feature [owner element]
            2.7.2.2 required attribute information item with feature [owner element]
        2.7.3 Mapping Feature's XML Representation to Component Properties
    2.8 Property
        2.8.1 The Property Component
            2.8.1.1 Property Composition Model
        2.8.2 XML Representation of Property Component
            2.8.2.1 ref attribute information item with property [owner element]
            2.8.2.2 value element information item with property [parent]
            2.8.2.3 constraint element information item with property [parent]
        2.8.3 Mapping Property's XML Representation to Component Properties
    2.9 Binding
        2.9.1 The Binding Component
        2.9.2 XML Representation of Binding Component
            2.9.2.1 name attribute information item with binding [owner element]
            2.9.2.2 interface attribute information item with binding [owner element]
            2.9.2.3 type attribute information item with binding [owner element]
            2.9.2.4 Binding extension elements
        2.9.3 Mapping Binding's XML Representation to Component Properties
    2.10 Binding Fault
        2.10.1 The Binding Fault Component
        2.10.2 XML Representation of Binding Fault Component
            2.10.2.1 ref attribute information item with fault [owner element]
            2.10.2.2 Binding Fault extension elements
        2.10.3 Mapping Binding Fault's XML Representation to Component Properties
    2.11 Binding Operation
        2.11.1 The Binding Operation Component
        2.11.2 XML Representation of Binding Operation Component
            2.11.2.1 ref attribute information item with operation [owner element]
            2.11.2.2 Binding Operation extension elements
        2.11.3 Mapping Binding Operation's XML Representation to Component Properties
    2.12 Binding Message Reference
        2.12.1 The Binding Message Reference Component
        2.12.2 XML Representation of Binding Message Reference Component
            2.12.2.1 messageLabel attribute information item with input or output [owner element]
            2.12.2.2 Binding Message Reference extension elements
        2.12.3 Mapping Binding Message Reference's XML Representation to Component Properties
    2.13 Binding Fault Reference
        2.13.1 The Binding Fault Reference Component
        2.13.2 XML Representation of Binding Fault Reference Component
            2.13.2.1 ref attribute information item with infault or outfault [owner element]
            2.13.2.2 messageLabel attribute information item with infault or outfault [owner element]
            2.13.2.3 Binding Fault Reference extension elements
        2.13.3 Mapping Binding Fault Reference's XML Representation to Component Properties
    2.14 Service
        2.14.1 The Service Component
        2.14.2 XML Representation of Service Component
            2.14.2.1 name attribute information item with service [owner element]
            2.14.2.2 interface attribute information item with service [owner element]
        2.14.3 Mapping Service's XML Representation to Component Properties
    2.15 Endpoint
        2.15.1 The Endpoint Component
        2.15.2 XML Representation of Endpoint Component
            2.15.2.1 name attribute information item with endpoint [owner element]
            2.15.2.2 binding attribute information item with endpoint [owner element]
            2.15.2.3 address attribute information item with endpoint [owner element]
            2.15.2.4 Endpoint extension elements
        2.15.3 Mapping Endpoint's XML Representation to Component Properties
    2.16 XML Schema 1.0 Simple Types Used in the Component Model
    2.17 Equivalence of Components
    2.18 Symbol Spaces
    2.19 QName resolution
    2.20 Comparing URIs and IRIs
3. Types
    3.1 Using W3C XML Schema Description Language
        3.1.1 Importing XML Schema
            3.1.1.1 namespace attribute information item
            3.1.1.2 schemaLocation attribute information item
        3.1.2 Inlining XML Schema
            3.1.2.1 targetNamespace attribute information item
        3.1.3 References to Element Declarations and Type Definitions
    3.2 Using Other Schema Languages
    3.3 Describing Messages that Refer to Services and Endpoints
        3.3.1 wsdlx:interface attribute information item
        3.3.2 wsdlx:binding attribute information item
        3.3.3 wsdlx:interface and wsdlx:binding Consistency
        3.3.4 Use of wsdlx:interface and wsdlx:binding with xs:anyURI
4. Modularizing WSDL 2.0 descriptions
    4.1 Including Descriptions
        4.1.1 location attribute information item with include [owner element]
    4.2 Importing Descriptions
        4.2.1 namespace attribute information item
        4.2.2 location attribute information item with import [owner element]
5. Documentation
6. Language Extensibility
    6.1 Element based Extensibility
        6.1.1 Mandatory extensions
        6.1.2 required attribute information item
    6.2 Attribute-based Extensibility
    6.3 Extensibility Semantics
7. Locating WSDL 2.0 Documents
    7.1 wsdli:wsdlLocation attribute information item
8. Conformance
    8.1 XML Information Set Conformance
9. XML Syntax Summary (Non-Normative)
10. References
    10.1 Normative References
    10.2 Informative References

Appendices

A. The application/wsdl+xml Media Type
    A.1 Registration
    A.2 Fragment Identifiers
        A.2.1 The Description Component
        A.2.2 The Element Declaration Component
        A.2.3 The Type Definition Component
        A.2.4 The Interface Component
        A.2.5 The Interface Fault Component
        A.2.6 The Interface Operation Component
        A.2.7 The Interface Message Reference Component
        A.2.8 The Interface Fault Reference Component
        A.2.9 The Binding Component
        A.2.10 The Binding Fault Component
        A.2.11 The Binding Operation Component
        A.2.12 The Binding Message Reference Component
        A.2.13 The Binding Fault Reference Component
        A.2.14 The Service Component
        A.2.15 The Endpoint Component
        A.2.16 The Feature Component
        A.2.17 The Property Component
        A.2.18 Extension Components
    A.3 Security considerations
B. Acknowledgements (Non-Normative)
C. IRI-References for WSDL 2.0 Components (Non-Normative)
    C.1 WSDL 2.0 IRIs
    C.2 Example
D. Component Summary (Non-Normative)
E. Part 1 Change Log (Non-Normative)
    E.1 WSDL 2.0 Specification Changes
F. Assertion Summary (Non-Normative)

1. Introduction

Web Services Description Language Version 2.0 (WSDL 2.0) provides a model and an XML format for describing Web services. WSDL 2.0 enables one to separate the description of the abstract functionality offered by a service from concrete details of a service description such as “how” and “where” that functionality is offered.

This specification defines a language for describing the abstract functionality of a service as well as a framework for describing the concrete details of a service description. It also defines the conformance criteria for documents in this language. The WSDL Version 2.0 Part 2: Adjuncts specification [WSDL 2.0 Adjuncts] describes extensions for Message Exchange Patterns, SOAP modules, and a language for describing such concrete details for SOAP 1.2 [SOAP 1.2 Part 1: Messaging Framework] and HTTP [IETF RFC 2616].

1.1 Web Service

WSDL 2.0 describes a Web service in two fundamental stages: one abstract and one concrete. Within each stage, the description uses a number of constructs to promote reusability of the description and to separate independent design concerns.

At an abstract level, WSDL 2.0 describes a Web service in terms of the messages it sends and receives; messages are described independent of a specific wire format using a type system, typically XML Schema.

An operation associates a message exchange pattern with one or more messages. A message exchange pattern identifies the sequence and cardinality of messages sent and/or received as well as who they are logically sent to and/or received from. An interface groups together operations without any commitment to transport or wire format.

At a concrete level, a binding specifies transport and wire format details for one or more interfaces. An endpoint associates a network address with a binding. And finally, a service groups together endpoints that implement a common interface.

1.2 Document Conformance

An element information item (as defined in [XML Information Set]) whose namespace name is "http://www.w3.org/2006/01/wsdl" and whose local part is description conforms to this specification if it is valid according to the XML Schema for that element as defined by this specification (http://www.w3.org/2006/01/wsdl/wsdl20.xsd) and additionally adheres to all the constraints contained in this specification family and conforms to the specifications of any extensions contained in it. Such a conformant element information item constitutes a WSDL 2.0 document.

The definition of the WSDL 2.0 language is based on the XML Information Set [XML Information Set] but also imposes many semantic constraints over and above structural conformance to this XML Infoset. In order to precisely describe these constraints, and as an aid in precisely defining the meaning of each WSDL 2.0 document, the WSDL 2.0 specification defines a component model 2. Component Model as an additional layer of abstraction above the XML Infoset. Constraints and meaning are defined in terms of this component model, and the definition of each component includes a mapping that specifies how values in the component model are derived from corresponding items in the XML Infoset.

An XML 1.0 document that is valid with respect to the WSDL 2.0 XML Schema and that maps to a valid WSDL 2.0 Component Model is conformant to the WSDL 2.0 specification.

1.3 The Meaning of a Service Description

A WSDL 2.0 service description indicates how potential clients are intended to interact with the described service. It represents an assertion that the described service fully implements and conforms to what the WSDL 2.0 document describes. For example, as further explained in section 6.1.1 Mandatory extensions, if the WSDL 2.0 document specifies a particular optional extension, the functionality implied by that extension is only optional to the client. It must be supported by the Web service.

A WSDL 2.0 interface describes potential interaction with a service--not required interaction. The declaration of an operation in a WSDL 2.0 interface is not an assertion that the interaction described by the operation must occur. Rather it is an assertion that if such an interaction is (somehow) initiated, then the declared operation describes how that interaction is intended to occur.

1.4 Notational Conventions

All parts of this specification are normative, with the EXCEPTION of notes, pseudo-schemas, examples, and sections explicitly marked as “Non-Normative”.

1.4.1 RFC 2119 Keywords

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

1.4.2 RFC 3986 Namespaces

Namespace names of the general form:

  • "http://example.org/..." and

  • "http://example.com/..."

represent application or context-dependent URIs [IETF RFC 3986].

1.4.3 XML Schema anyURI

This specification uses the XML Schema type xs:anyURI (see [XML Schema: Datatypes]). It is defined so that xs:anyURI values are essentially IRIs (see [IETF RFC 3987]). The conversion from xs:anyURI values to an actual URI is via an escaping procedure defined by (see [XML Linking Language (XLink) 1.0]), which is identical in most respects to IRI Section 3.1.

For interoperability, WSDL authors are advised to avoid the US-ASCII characters: "<", ">", '"', space, "{", "}", "|", "\", "^", and "`", which are allowed by the xs:anyURI type, but disallowed in IRIs.

1.4.4 Prefixes and Namespaces Used in This Specification

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/2006/01/wsdl"

Defined by this specification.

wsdli

"http://www.w3.org/2006/01/wsdl-instance"

Defined by this specification 7.1 wsdli:wsdlLocation attribute information item.

wsdlx

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

Defined by this specification 3.3 Describing Messages that Refer to Services and Endpoints.

wrpc

"http://www.w3.org/2006/01/wsdl/rpc"

Defined by WSDL 2.0: Adjuncts [WSDL 2.0 Adjuncts].

wsoap

"http://www.w3.org/2006/01/wsdl/soap"

Defined by WSDL 2.0: Adjuncts [WSDL 2.0 Adjuncts].

whttp

"http://www.w3.org/2006/01/wsdl/http"

Defined by WSDL 2.0: Adjuncts [WSDL 2.0 Adjuncts].

xs

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

Defined in the W3C XML Schema specification [XML Schema: Structures], [XML Schema: Datatypes].

xsi

"http://www.w3.org/2001/XMLSchema-instance"

Defined in the W3C XML Schema specification [XML Schema: Structures], [XML Schema: Datatypes].

1.4.5 Terms Used in This Specification

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

Actual Value

As in [XML Schema: Structures], the phrase actual value is used to refer to the member of the value space of the simple type definition associated with an attribute information item which corresponds to its normalized value. This will often be a string, but may also be an integer, a boolean, an IRI-reference, etc.

Inlined Schema

An XML schema that is defined in the xs:types element information item of a WSDL 2.0 description. For example, an XML Schema defined in an xs:schema element information item 3.1.2 Inlining XML Schema.

1.4.6 XML Information Set Properties

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

1.4.7 WSDL 2.0 Component Model Properties

This specification defines and refers to properties in the WSDL 2.0 Component Model 2. 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.

1.4.8 Z Notation

Z Notation [Z Notation Reference Manual] 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 [Fuzz 2000].

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 preceding 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 1.4.6 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 1.4.7 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.

1.4.9 BNF Pseudo-Schemas

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. Elements with simple content are conventionally assigned a value which corresponds to the type of their content, as defined in the normative schema. Pseudo schemas do not include extensibility points for brevity.

<!-- sample pseudo-schema -->
<defined_element
      required_attribute_of_type_string="xs:string"
      optional_attribute_of_type_int="xs:int"? >
  <required_element />
  <optional_element />?
  <one_or_more_of_these_elements />+
  [ <choice_1 /> | <choice_2 /> ]*
</defined_element>

1.4.10 Assertions

Assertions about WSDL 2.0 documents and components that are not enforced by the normative XML schema for WSDL 2.0 are marked in the non-normative version of this specification by a dagger symbol (†) at the end of a sentence. Each assertion has been assigned a unique identifier that consists of a descriptive textual prefix and a unique numeric suffix. The numeric suffixes are assigned sequentially and never reused so there may be gaps in the sequence. The assertion identifiers MAY be used by implementations of this specification for any purpose, e.g. error reporting.

The assertions and their identifiers are summarized in an Assertion Summary Appendix that is included the non-normative version of this specification.

2. Component Model

This section describes the conceptual model of WSDL 2.0 as a set of components with attached properties, which collectively describe a Web service. This model is called the Component Model of WSDL 2.0. A valid WSDL 2.0 component model is a set of WSDL 2.0 components and properties that satisfy all the requirements given in this specification as indicated by keywords whose interpretation is defined by RFC 2119 [IETF RFC 2119].

ComponentModel  [ show all ]  [ hide all ]

A WSDL 2.0 document, and its related documents, defines a set of components that together form an instance of a Component Model. This specification defines the structure and constraints on the components in a valid component model instance.

Let ComponentModel be the set of valid component model instances:

ComponentModel
DescriptionCM
ElementDeclarationCM
TypeDefinitionCM
FeatureCM
PropertyCM
InterfaceCM
InterfaceFaultCM
InterfaceOperationCM
InterfaceMessageReferenceCM
InterfaceFaultReferenceCM
BindingCM
BindingFaultCM
BindingOperationCM
BindingMessageReferenceCM
BindingFaultReferenceCM
ServiceCM
EndpointCM
See DescriptionCM, ElementDeclarationCM, TypeDefinitionCM, FeatureCM, PropertyCM, InterfaceCM, InterfaceFaultCM, InterfaceOperationCM, InterfaceMessageReferenceCM, InterfaceFaultReferenceCM, BindingCM, BindingFaultCM, BindingOperationCM, BindingMessageReferenceCM, BindingFaultReferenceCM, ServiceCM, EndpointCM.

The definition of ComponentModel is built up from definitions for each of the component types. A component model instance is valid if and only if the constraints on each of the component types are satisfied. The component type definitions are given in the following sections.

Components are typed collections of properties that correspond to different aspects of Web services. Each subsection herein describes a different type of component, its defined properties, and its representation as an XML Infoset [XML Information Set].

Component  [ show all ]  [ hide all ]

Let Component be the union of each of the component types that appear in the WSDL 2.0 component model:

Component ::=
      description〈〈Description〉〉|
      elementDecl〈〈ElementDeclaration〉〉|
      typeDef〈〈TypeDefinition〉〉|
      interface〈〈Interface〉〉|
      interfaceFault〈〈InterfaceFault〉〉|
      interfaceOp〈〈InterfaceOperation〉〉|
      interfaceMessageRef〈〈InterfaceMessageReference〉〉|
      interfaceFaultRef〈〈InterfaceFaultReference〉〉|
      feature〈〈Feature〉〉|
      property〈〈Property〉〉|
      binding〈〈Binding〉〉|
      bindingFault〈〈BindingFault〉〉|
      bindingOp〈〈BindingOperation〉〉|
      bindingMessageRef〈〈BindingMessageReference〉〉|
      bindingFaultRef〈〈BindingFaultReference〉〉|
      service〈〈Service〉〉|
      endpoint〈〈Endpoint〉〉
See Description, ElementDeclaration, TypeDefinition, Interface, InterfaceFault, InterfaceOperation, InterfaceMessageReference, InterfaceFaultReference, Feature, Property, Binding, BindingFault, BindingOperation, BindingMessageReference, BindingFaultReference, Service, Endpoint.

The Component type is an example of a Z Notation free type. The structure of a free type is similar to that of a variant record or discriminated union datatype that are found in some common programming languages. Each of the members of this union is formally defined in the following sections.

ID...
ID  [ show all ]  [ hide all ]

When a component property is said to contain another component or a set of other components, the intended meaning is that the component property contains a reference to another component or a set of references to other components. Every component contains an unique identifier that is used to express references.

Let ID be the set of all component identifier values:

[ID]

The ID type is an example of a Z Notation basic set. The structure of a basic set is immaterial. The only relevant aspect of ID is that it contains enough members to uniquely identify each component, and that these identifiers can be compared for equality. These identifiers are similar to XML element ids or object identifiers that are found in common object-oriented programming languages.

Identifier  [ show all ]  [ hide all ]

Every component has an identifier which uniquely identifies it within a component model instance.

Let Identifier be the set of component identifier properties:

  • Let id be the identifier of the component.

Identifier
id : ID
See ID.

The Identifier set is a an example of Z Notation schema. The structure of a Z schema is similar to that of a record or struct datatype that are found in many common programming languages. The fields of an instance of a Z schema are selected using the usual dot notation, e.g. x.id selects the id field of the instance x.

All component properties that contain an ID, except for Identifier, refer to other components. Every ID value that appears in a component reference corresponds to a unique component in the component model with that identifier.

Id...
Id  [ show all ]  [ hide all ]

Let Id map components to their identifiers:

Id : Component→ID
∀x : Description • Id(description(x)) = x.id
∀x : ElementDeclaration • Id(elementDecl(x)) = x.id
∀x : TypeDefinition • Id(typeDef(x)) = x.id
∀x : Interface • Id(interface(x)) = x.id
∀x : InterfaceFault • Id(interfaceFault(x)) = x.id
∀x : InterfaceOperation • Id(interfaceOp(x)) = x.id
∀x : InterfaceMessageReference • Id(interfaceMessageRef(x)) = x.id
∀x : InterfaceFaultReference • Id(interfaceFaultRef(x)) = x.id
∀x : Feature • Id(feature(x)) = x.id
∀x : Property • Id(property(x)) = x.id
∀x : Binding • Id(binding(x)) = x.id
∀x : BindingFault • Id(bindingFault(x)) = x.id
∀x : BindingOperation • Id(bindingOp(x)) = x.id
∀x : BindingMessageReference • Id(bindingMessageRef(x)) = x.id
∀x : BindingFaultReference • Id(bindingFaultRef(x)) = x.id
∀x : Service • Id(service(x)) = x.id
∀x : Endpoint • Id(endpoint(x)) = x.id
See Component, ID, Description, ElementDeclaration, TypeDefinition, Interface, InterfaceFault, InterfaceOperation, InterfaceMessageReference, InterfaceFaultReference, Feature, Property, Binding, BindingFault, BindingOperation, BindingMessageReference, BindingFaultReference, Service, Endpoint.

The Id function is an example of a Z Notation axiomatic definition. An axiomatic definition declares an object and then characterises it with a set of axioms or logical constraints that it satisfies. In this case, the Id function is constrained by giving its value on each possible type of component, which uniquely defines it.

ComponentModel1  [ show all ]  [ hide all ]

A component model is a set of uniquely identified components that satisfy a set of validity constraints which are described in the following sections.

Let ComponentModel1 be the base set of component models. This set will be further constrained in the following sections:

  • Let components be the set of components in the component model.

  • Let componentIds be the set of identifiers of components in the component model.

ComponentModel1
components :ℙComponent
componentIds :ℙID
∀x, y : components •
      Id(x) = Id(y)⇒x = y
componentIds = { x : components • Id(x) }
See Component, Id.

  • No two components have the same identifier.

IdentifierValid  [ show all ]  [ hide all ]

An identifier is valid if it is the identifier of a component in the component model.

Let IdentifierValid express this validity constraint:

IdentifierValid
ComponentModel1
Identifier
id∈componentIds
See ComponentModel1, Identifier.
InterfaceComponents  [ show all ]  [ hide all ]

In order to express the additional contraints on the component model, it is convenient to define the subsets of components of each type and their corresponding subsets of identifiers.

Let InterfaceComponents define the subsets of components that are related to the Interface component:

InterfaceComponents
ComponentModel1
interfaceComps :ℙInterface
interfaceFaultComps :ℙInterfaceFault
interfaceOpComps :ℙInterfaceOperation
interfaceMessageRefComps :ℙInterfaceMessageReference
interfaceFaultRefComps :ℙInterfaceFaultReference
interfaceComps = { x : Interface |
      interface(x)∈components }
interfaceFaultComps = { x : InterfaceFault |
      interfaceFault(x)∈components }
interfaceOpComps = { x : InterfaceOperation |
      interfaceOp(x)∈components }
interfaceMessageRefComps = { x : InterfaceMessageReference |
      interfaceMessageRef(x)∈components }
interfaceFaultRefComps = { x : InterfaceFaultReference |
      interfaceFaultRef(x)∈components }
See ComponentModel1, Interface, InterfaceFault, InterfaceOperation, InterfaceMessageReference, InterfaceFaultReference.

The definition of InterfaceComponents is an example of Z Notation schema inclusion. In Z schema inclusion all the fields and constraints of the included Z schema, e.g. ComponentModel1 are added to the including Z schema, e.g. InterfaceComponents.

InterfaceComponentIds  [ show all ]  [ hide all ]

Let InterfaceComponentIds define the subsets of component identifiers that are related to the Interface component:

InterfaceComponentIds
InterfaceComponents
interfaceIds :ℙID
interfaceFaultIds :ℙID
interfaceOpIds :ℙID
interfaceMessageRefIds :ℙID
interfaceFaultRefIds :ℙID
interfaceIds = { x : interfaceComps • x.id }
interfaceFaultIds = { x : interfaceFaultComps • x.id }
interfaceOpIds = { x : interfaceOpComps • x.id }
interfaceMessageRefIds = { x : interfaceMessageRefComps • x.id }
interfaceFaultRefIds = { x : interfaceFaultRefComps • x.id }
See InterfaceComponents, ID.
BindingComponents  [ show all ]  [ hide all ]

Let BindingComponents define the subsets of components that are related to the Binding component:

BindingComponents
ComponentModel1
bindingComps :ℙBinding
bindingFaultComps :ℙBindingFault
bindingOpComps :ℙBindingOperation
bindingMessageRefComps :ℙBindingMessageReference
bindingFaultRefComps :ℙBindingFaultReference
bindingComps = { x : Binding |
      binding(x)∈components }
bindingFaultComps = { x : BindingFault |
      bindingFault(x)∈components }
bindingOpComps = { x : BindingOperation |
      bindingOp(x)∈components }
bindingMessageRefComps = { x : BindingMessageReference |
      bindingMessageRef(x)∈components }
bindingFaultRefComps = { x : BindingFaultReference |
      bindingFaultRef(x)∈components }
See ComponentModel1, Binding, BindingFault, BindingOperation, BindingMessageReference, BindingFaultReference.
BindingComponentIds  [ show all ]  [ hide all ]

Let BindingComponentIds define the subsets of component identifiers that are related to the Binding component:

BindingComponentIds
BindingComponents
bindingIds :ℙID
bindingFaultIds :ℙID
bindingOpIds :ℙID
bindingMessageRefIds :ℙID
bindingFaultRefIds :ℙID
bindingIds = { x : bindingComps • x.id }
bindingFaultIds = { x : bindingFaultComps • x.id }
bindingOpIds = { x : bindingOpComps • x.id }
bindingMessageRefIds = { x : bindingMessageRefComps • x.id }
bindingFaultRefIds = { x : bindingFaultRefComps • x.id }
See BindingComponents, ID.
ServiceComponents  [ show all ]  [ hide all ]

Let ServiceComponents define the subsets of components that are related to the Service component:

  • Let serviceComps be the subset of Service components.

  • Let endpointComps be the subset of Endpoint components.

ServiceComponents
ComponentModel1
serviceComps :ℙService
endpointComps :ℙEndpoint
serviceComps = { x : Service |
      service(x)∈components }
endpointComps = { x : Endpoint |
      endpoint(x)∈components }
See ComponentModel1, Service, Endpoint.
ServiceComponentIds  [ show all ]  [ hide all ]

Let ServiceComponentIds define the subsets of component identifiers that are related to the Service component:

  • Let serviceIds be the subset of Service component identifiers.

  • Let endpointIds be the subset of Endpoint component identifiers.

ServiceComponentIds
ServiceComponents
serviceIds :ℙID
endpointIds :ℙID
serviceIds = { x : serviceComps • x.id }
endpointIds = { x : endpointComps • x.id }
See ServiceComponents, ID.
OtherComponents  [ show all ]  [ hide all ]

Let OtherComponents define the subsets of the other component types:

  • Let descriptionComps be the subset of Description components.

  • Let elementDeclComps be the subset of Element Declaration components.

  • Let typeDefComps be the subset of Type Definition components.

  • Let featureComps be the subset of Feature components.

  • Let propertyComps be the subset of Property components.

OtherComponents
ComponentModel1
descriptionComps :ℙDescription
elementDeclComps :ℙElementDeclaration
typeDefComps :ℙTypeDefinition
featureComps :ℙFeature
propertyComps :ℙProperty
descriptionComps = { x : Description |
      description(x)∈components }
elementDeclComps = { x : ElementDeclaration |
      elementDecl(x)∈components }
typeDefComps = { x : TypeDefinition |
      typeDef(x)∈components }
featureComps = { x : Feature |
      feature(x)∈components }
propertyComps = { x : Property |
      property(x)∈components }
See ComponentModel1, Description, ElementDeclaration, TypeDefinition, Feature, Property.
OtherComponentIds  [ show all ]  [ hide all ]

Let OtherComponentIds define the subsets of other component identifiers:

  • Let descriptionIds be the subset of Description component identifiers.

  • Let elementDeclIds be the subset of Element Declaration component identifiers.

  • Let typeDefIds be the subset of Type Definition Operation component identifiers.

  • Let featureIds be the subset of Feature component identifiers.

  • Let propertyIds be the subset of Property component identifiers.

OtherComponentIds
OtherComponents
descriptionIds :ℙID
elementDeclIds :ℙID
typeDefIds :ℙID
featureIds :ℙID
propertyIds :ℙID
descriptionIds = { x : descriptionComps • x.id }
elementDeclIds = { x : elementDeclComps • x.id }
typeDefIds = { x : typeDefComps • x.id }
featureIds = { x : featureComps • x.id }
propertyIds = { x : propertyComps • x.id }
See OtherComponents, ID.
ComponentModel2  [ show all ]  [ hide all ]

Let ComponentModel2 be the basic component model, augmented with the definitions of the subsets of each component type and their corresponding identifiers:

ComponentModel2≙
      InterfaceComponentIds∧
      BindingComponentIds∧
      ServiceComponentIds∧
      OtherComponentIds
See InterfaceComponentIds, BindingComponentIds, ServiceComponentIds, OtherComponentIds.

The definition of ComponentModel2 is an example of Z Notation schema conjunction. In Z schema conjunction, the resulting Z schema, e.g. ComponentModel2, contains all the fields of the conjoined Z schemas, e.g. InterfaceComponentIds, BindingComponentIds, ServiceComponentIds, and OtherComponentIds, and its constraint is the conjunction (logical and) of their constraints.

Base...
Base  [ show all ]  [ hide all ]

Many of the component types in the component model have a set of Feature components and a set of Property components, in addition to an identifer. It is convenient to group these common fields into a base Z schema that can be included in other component schemas.

Let Base be the common base Z schema for all component types that have an identifier and contain sets of Feature and Property components:

Base
Identifier
Features
Properties
See Identifier, Features, Properties.
BaseValid  [ show all ]  [ hide all ]

The base properties of a component are valid when the Features and Properties properties are valid:

Let BaseValid be this validity constraint on the base fields of a component:

BaseValid
IdentifierValid
FeaturesValid
PropertiesValid
See IdentifierValid, FeaturesValid, PropertiesValid.
NestedBase  [ show all ]  [ hide all ]

Nested components have an additional {parent} property.

Let NestedBase be the common base schema for all nested component types:

NestedBase
Base
Parent
See Base, Parent.
NestedBaseValid  [ show all ]  [ hide all ]

The properties of a nested base component are valid when the base properties are valid and the {parent} property is valid.

Let NestedBaseValid be the validity constraints for nested components:

NestedBaseValid
BaseValid
ParentValid
See BaseValid, ParentValid.

Properties are unordered and unique with respect to the component they are associated with. Individual properties' definitions may constrain their content (e.g., to a typed value, another component, or a set of typed values or components), and components may require the presence of a property to be considered conformant. Such properties are marked as REQUIRED, whereas those that are not required to be present are marked as OPTIONAL. By convention, when specifying the mapping rules from the XML Infoset representation of a component to the component itself, an optional property that is absent in the component in question is described as being “empty”. Unless otherwise specified, when a property is identified as being a collection (a set or a list), its value may be a 0-element (empty) collection. In order to simplify the presentation of the rules that deal with sets of components, for all OPTIONAL properties whose type is a set, the absence of such a property from a component MUST be treated as semantically equivalent to the presence of a property with the same name and whose value is the empty set. In other words, every OPTIONAL set-valued property MUST be assumed to have the empty set as its default value, to be used in case the property is absent.

OPTIONAL  [ show all ]  [ hide all ]

An OPTIONAL simple property type is treated as a set-valued type that contains at most one member. If the property is absent then its value is the empty set. If the property is present then its value is the singleton set that contains the actual value of the property.

Let OPTIONAL[X] be the OPTIONAL values of type X where X is a property type:

[X]
OPTIONAL :ℙ(ℙX)
OPTIONAL = {∅}∪{ x : X • {x} }

  • An optional value of type X is either the empty set or a singleton set that contains one member of X.

For example, OPTIONAL[{True, False}] = {∅, {True}, {False}}.

The definition of OPTIONAL is an example of Z Notation generic definition. A Z generic definition defines an object whose type depends on the types of one or more sets that are given as arguments to the definition. A Z generic definition is similar to a generic, template, or parameterized type that are found in common programming languages.

Component definitions are serializable in XML 1.0 format but are independent of any particular serialization of the component model. Component definitions use a subset (see 2.16 XML Schema 1.0 Simple Types Used in the Component Model) of the simple types defined by the XML Schema 1.0 specification [XML Schema: Datatypes].

In addition to the direct XML Infoset representation described here, the component model allows components external to the Infoset through the mechanisms described in 4. Modularizing WSDL 2.0 descriptions.

A component model can be extracted from a given XML Infoset which conforms to the XML Schema for WSDL 2.0 by recursively mapping Information Items to their identified components, starting with the wsdl:description element information item. This includes the application of the mechanisms described in 4. Modularizing WSDL 2.0 descriptions.

This document does not specify a means of producing an XML Infoset representation from a component model instance. In particular, there are in general many valid ways to modularize a given component model instance into one or more XML Infosets.

2.1 Description

2.1.1 The Description Component

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.

Type system components describe the constraints on a message's content. By default, these constraints are expressed in terms of the [XML Information Set], 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 6. Language Extensibility. 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.

ElementContentModel  [ show all ]  [ hide all ]

Let ElementContentModel be the set of all models that define the allowable values for the [children] and [attribute] properties of an element information item:

[ElementContentModel]

The detailed structure of ElementContentModel is immaterial for the purposes of this specification. It is can be safely thought of as some superset of the set of all XML Schema complex type definitions.

An Element Declaration component defines the name and content model of an element information item such as that defined by an XML Schema global element declaration. It has a {name} property that is the QName of the element information item and a {system} property that is the namespace IRI of the extension element information items for the type system, e.g. the namespace of XML Schema.

ElementDeclaration  [ show all ]  [ hide all ]

Let ElementDeclaration be the type of Element Declaration components:

  • Let name be the QName defined by the [local name] and [namespace name] properties of the element information item.

  • Let system be the namespace IRI of the type system.

  • Let elementContentModel be the element content model that constrains the allowable contents of the [children] and [attribute] properties of the element information item.

ElementDeclaration
Identifier
name : QName
system : AbsoluteURI
elementContentModel : ElementContentModel
See QName, AbsoluteURI, ElementContentModel.
ElementDeclarationCM  [ show all ]  [ hide all ]

Each Element Declaration component is uniquely identified by the combination of its {name} and {system} properties within the component model.

Let ElementDeclarationCM express this constraint:

ElementDeclarationCM
ComponentModel2
∀x, y : elementDeclComps |
      x.name = y.name∧
      x.system = y.system •
            x = y
See ComponentModel2.

A Type Definition component defines the content model of an element information item such as that defined by an XML Schema global type definition. It has a {name} property that is the QName of the type and a {system} property that is the namespace IRI of the extension element information items for the type system, e.g. the namespace of XML Schema.

TypeDefinition  [ show all ]  [ hide all ]

Let TypeDefinition be the type of the Type Definition component:

  • Let name be the QName of the type definition.

  • Let system be the namespace IRI of the type system.

  • Let elementContentModel be the element content model that constrains the allowable contents of the [children] and [attribute] properties of the element information item described by the type definition.

TypeDefinition
Identifier
name : QName
system : AbsoluteURI
elementContentModel : ElementContentModel
See QName, AbsoluteURI, ElementContentModel.
TypeDefinitionCM  [ show all ]  [ hide all ]

Each Type Definition component is uniquely identified by the combination of its {name} and {system} properties within the component model.

Let TypeDefinitionCM express this constraint:

TypeDefinitionCM
ComponentModel2
∀x, y : typeDefComps |
      x.name = y.name∧
      x.system = y.system •
            x = y
See ComponentModel2.

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.

TopLevelComponent  [ show all ]  [ hide all ]

Let TopLevelComponent be the set of all top-level components:

TopLevelComponent ==
      ranelementDecl∪
      rantypeDef∪
      raninterface∪
      ranbinding∪
      ranservice
See Component.
Name...
Name  [ show all ]  [ hide all ]

Let Name map a top-level component to its QName {name} property:

Name : TopLevelComponent→QName
∀x : ElementDeclaration •
      Name(elementDecl(x)) = x.name
∀x : TypeDefinition •
      Name(typeDef(x)) = x.name
∀x : Interface •
      Name(interface(x)) = x.name
∀x : Binding •
      Name(binding(x)) = x.name
∀x : Service •
      Name(service(x)) = x.name
See TopLevelComponent, QName, Component, ElementDeclaration, TypeDefinition, Interface, Binding, Service.
Parent  [ show all ]  [ hide all ]

Let Parent represent the {parent} property of a nested component:

Parent
Identifier
parent : ID
See Identifier, ID.
ParentValid  [ show all ]  [ hide all ]

The parent of a nested component in the component model MUST also be in the component model. No component is its own parent.

Let ParentValid represent these validity constraints:

ParentValid
ComponentModel1
Parent
parent∈componentIds
parent≠id
See ComponentModel1, Parent.
NestedComponent  [ show all ]  [ hide all ]

Let NestedComponent be the set of all nested components:

NestedComponent ==
      raninterfaceFault∪
      raninterfaceOp∪
      raninterfaceMessageRef∪
      raninterfaceFaultRef∪
      ranbindingFault∪
      ranbindingOp∪
      ranbindingMessageRef∪
      ranbindingFaultRef∪
      ranendpoint∪
      ranfeature∪
      ranproperty
See Component.
ParentId  [ show all ]  [ hide all ]

Let ParentId map a nested component to its parent component identifier:

ParentId : NestedComponent→ID
∀x : InterfaceFault •
      ParentId(interfaceFault(x)) = x.parent
∀x : InterfaceOperation •
      ParentId(interfaceOp(x)) = x.parent
∀x : InterfaceMessageReference •
      ParentId(interfaceMessageRef(x)) = x.parent
∀x : InterfaceFaultReference •
      ParentId(interfaceFaultRef(x)) = x.parent
∀x : BindingFault •
      ParentId(bindingFault(x)) = x.parent
∀x : BindingOperation •
      ParentId(bindingOp(x)) = x.parent
∀x : BindingMessageReference •
      ParentId(bindingMessageRef(x)) = x.parent
∀x : BindingFaultReference •
      ParentId(bindingFaultRef(x)) = x.parent
∀x : Endpoint •
      ParentId(endpoint(x)) = x.parent
∀x : Feature •
      ParentId(feature(x)) = x.parent
∀x : Property •
      ParentId(property(x)) = x.parent
See NestedComponent, ID, InterfaceFault, InterfaceOperation, InterfaceMessageReference, InterfaceFaultReference, BindingFault, BindingOperation, BindingMessageReference, BindingFaultReference, Endpoint, Feature, Property.

The properties of the Description component are as follows:

Description  [ show all ]  [ hide all ]

Let Description be the set of all Description components:

Description
Identifier
interfaces :ℙID
bindings :ℙID
services :ℙID
elementDeclarations :ℙID
typeDefinitions :ℙID
See ID.
DescriptionKey  [ show all ]  [ hide all ]

The component model contains a unique Description component.

Let DescriptionKey express this constraint on the Description component:

  • Let descriptionComp be the unique Description component.

DescriptionKey
ComponentModel2
descriptionComp : Description
descriptionComps = {descriptionComp}
See ComponentModel2, Description.

  • The component model contains a unique Description component.

DescriptionCM  [ show all ]  [ hide all ]

Each component refered to by the properties of the Description component must exist in the component model.

Let DescriptionCM express these referential integrity constraints on the Description component:

DescriptionCM
DescriptionKey
descriptionComp.interfaces = interfaceIds
descriptionComp.bindings = bindingIds
descriptionComp.services = serviceIds
descriptionComp.elementDeclarations = elementDeclIds
descriptionComp.typeDefinitions = typeDefIds
See DescriptionKey.

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 wsdl:import element information item for that namespace (see 4.2 Importing Descriptions ).† Furthermore, all QName references, whether to the same or to different namespaces MUST resolve to components (see 2.19 QName resolution ).†

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

2.1.2 XML Representation of Description Component

<description
      targetNamespace="xs:anyURI" >
  <documentation />*
  [ <import /> | <include /> ]*
  <types />?
  [ <interface /> | <binding /> | <service /> ]*
</description>

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 wsdl:import element information items 4.2 Importing Descriptions 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 dereferenceable. 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 WSDL 2.0 document is split into multiple WSDL 2.0 documents (which may be combined as needed via 4.1 Including Descriptions), then the targetNamespace attribute information item SHOULD resolve to a master WSDL 2.0 document that includes all the WSDL 2.0 documents needed for that service description. This approach enables the WSDL 2.0 component designator fragment identifiers to be properly resolved.

Imported components have different target namespace values from the WSDL 2.0 document that is importing them.† Thus importing is the mechanism to use components from one namespace in definition of components from another namespace.

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:

  • A [local name] of description .

  • A [namespace name] of "http://www.w3.org/2006/01/wsdl".

  • One or more attribute information items amongst its [attributes] as follows:

    • A REQUIRED targetNamespace attribute information item as described below in 2.1.2.1 targetNamespace attribute information item.

    • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/2006/01/wsdl".

  • Zero or more element information items amongst its [children], in order as follows:

    1. Zero or more documentation element information items (see 5. Documentation).

    2. Zero or more element information items from among the following, in any order:

      • Zero or more include element information items (see 4.1 Including Descriptions)

      • Zero or more import element information items (see 4.2 Importing Descriptions)

      • Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2006/01/wsdl".

    3. An OPTIONAL types element information item (see 3. Types).

    4. Zero or more element information items from among the following, in any order:

2.1.2.1 targetNamespace attribute information item

The targetNamespace attribute information item defines the namespace affiliation of top-level components defined in this description element information item. Interface, Binding and Service are top-level components.

The targetNamespace attribute information item has the following Infoset properties:

  • A [local name] of targetNamespace

  • A [namespace name] which has no value

The type of the targetNamespace attribute information item is xs:anyURI. Its value MUST be an absolute IRI (see [IETF RFC 3987]) and should be dereferenceable.†

2.1.3 Mapping Description's XML Representation to Component Properties

The mapping from the XML Representation of the description element information item (see 2.1.2 XML Representation of Description Component) to the properties of the Description component is described in Table 2-1.


Table 2-1. Mapping from XML Representation to Description Component Properties
Property Value
{interfaces} The set of Interface components corresponding to all the interface element information items in the [children] of the description element information item, if any, plus any included (via wsdl:include ) or imported (via wsdl:import ) Interface components (see 4. Modularizing WSDL 2.0 descriptions).
{bindings} The set of Binding components corresponding to all the binding element information items in the [children] of the description element information item, if any, plus any included (via wsdl:include ) or imported (via wsdl:import ) Binding components (see 4. Modularizing WSDL 2.0 descriptions).
{services} The set of Service components corresponding to all the service element information items in the [children] of the description element information item, if any, plus any included (via wsdl:include ) or imported (via wsdl:import ) Service components (see 4. Modularizing WSDL 2.0 descriptions).
{element declarations} The set of Element Declaration components corresponding to all the element declarations defined as descendants of the types element information item, if any, plus any included (via xs:include ) or imported (via xs:import ) Element Declaration components. At a minimum this will include all the global element declarations defined by XML Schema element element information items. It MAY also include any declarations from some other type system which describes the [local name], [namespace name], [attributes] and [children] properties of an element information item.
{type definitions} The set of Type Definition components corresponding to all the type definitions defined as descendants of the types element information item, if any, plus any (via xs:include ) or imported (via xs:import ) Type Definition components. At a minimum this will include all the global type definitions defined by XML Schema simpleType and complexType element information items. It MAY also include any definitions from some other type system which describes the [attributes] and [children] properties of an element information item. It is an error if there are multiple type definitions for each QName.†

2.2 Interface

2.2.1 The Interface Component

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 2.17 Equivalence of Components 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 2.19 QName resolution). For instance, Binding components refer to interfaces in this way.

The properties of the Interface component are as follows:

Interface  [ show all ]  [ hide all ]

Let Interface be the set of all Interface components:

  • Let allExtendedInterfaces be the set off all interfaces that are extended directly or indirectly by this interface.

  • Let allInterfaceFaults be the set of all faults that are directly or indirectly on this interface.

  • Let allInterfaceOperations be the set of all operations that are directly or indirectly on this interface.

Interface
Base
name : QName
extendedInterfaces :ℙID
interfaceFaults :ℙID
interfaceOperations :ℙID
allExtendedInterfaces :ℙID
allInterfaceFaults :ℙID
allInterfaceOperations :ℙID
extendedInterfaces⊆allExtendedInterfaces
interfaceFaults⊆allInterfaceFaults
interfaceOperations⊆allInterfaceOperations
See Base, QName, ID.
InterfaceRI  [ show all ]  [ hide all ]

Each component referenced by an Interface component must exist in the component model.

Let InterfaceRI express the referential integrity constraints on the Interface component:

InterfaceRI
ComponentModel2
∀Interface |θInterface∈interfaceComps •
      BaseValid∧
      extendedInterfaces⊂interfaceIds∧
      interfaceFaults⊆interfaceFaultIds∧
      interfaceOperations⊆interfaceOpIds
See ComponentModel2, Interface, BaseValid.

This Z schema introduces some additional notation. The universal quantifier ∀Interface declares each field that is part of the Interface schema as an in-scope variable and constrains them to satify the rules for Interface. The expression θInterface assembles these variables into Interface record or struct. The expression θInterface∈interfaceComps constrains the Interface record to exist in the component model.

For each Interface component in the {interfaces} property of a Description component, the {name} property MUST be unique.†

InterfaceKey  [ show all ]  [ hide all ]

Let InterfaceKey express the QName uniqueness constraint on the Interface component:

InterfaceKey
ComponentModel2
∀x, y : interfaceComps |
      x.name = y.name • x = y
See ComponentModel2.
InterfaceParent  [ show all ]  [ hide all ]

An Interface component contains nested Interface Operation and Interface Fault components. These components MUST have the Interface component as their parent.

Let InterfaceParent express the constraints on the {parent} properties of the nested components of an Interface component:

InterfaceParent
ComponentModel2
∀i : interfaceComps;
      if : interfaceFaultComps;
      io : interfaceOpComps •
      if.id∈i.interfaceFaults⇔if.parent = i.id∧
      io.id∈i.interfaceOperations⇔io.parent = i.id
See ComponentModel2.
InterfaceAllExtendedInterfaces  [ show all ]  [ hide all ]

The set of all extended interfaces that are available on an Interface component consist of those that are declared on the component and those that are available on its extended interfaces.

Let InterfaceAllExtendedInterfaces express this definition:

InterfaceAllExtendedInterfaces
ComponentModel2
∀i : interfaceComps •
      i.allExtendedInterfaces = i.extendedInterfaces∪
            { x : interfaceComps; y : ID |
                  x.id∈i.extendedInterfaces∧
                  y∈x.allExtendedInterfaces • y }
See ComponentModel2.

  • An Interface component directly or indirectly extends an Interface component if it directly extends it, or if an Interface component that it directly extends, directly or indirectly extends it.

InterfaceExtendsAcyclic  [ show all ]  [ hide all ]

An Interface component MUST NOT directly or indirectly extend itself.

Let InterfaceExtendsAcyclic express this constraint:

InterfaceExtendsAcyclic
ComponentModel2
∀i : interfaceComps •
      i.id∉i.allExtendedInterfaces
See ComponentModel2.
InterfaceAllInterfaceOperations  [ show all ]  [ hide all ]

The set of all Interface Operation components that are available on an Interface component consist of those that are contained by the Interface component and those that are available on Interface components that it directly or indirectly extends.

Let InterfaceAllInterfaceOperations express this definition:

InterfaceAllInterfaceOperations
ComponentModel2
∀i : interfaceComps •
      i.allInterfaceOperations = i.interfaceOperations∪
            { x : interfaceComps; y : ID |
                  x.id∈i.allExtendedInterfaces∧
                  y∈x.interfaceOperations • y }
See ComponentModel2.
InterfaceAllInterfaceFaults  [ show all ]  [ hide all ]

The set of all Interface Operation components that are available on an Interface component consist of those that are contained by the Interface component and those that are available on Interface components that it directly or indirectly extends.

Let InterfaceAllInterfaceFaults express this definition:

InterfaceAllInterfaceFaults
ComponentModel2
∀i : interfaceComps •
      i.allInterfaceFaults = i.interfaceFaults∪
            { x : interfaceComps; y : ID |
                  x.id∈i.allExtendedInterfaces∧
                  y∈x.interfaceFaults • y }
See ComponentModel2.
InterfaceCM  [ show all ]  [ hide all ]

Let InterfaceCM be the conjunction of all the component model constraints on Interface components.

InterfaceCM≙
      InterfaceRI∧
      InterfaceKey∧
      InterfaceParent∧
      InterfaceAllExtendedInterfaces∧
      InterfaceExtendsAcyclic∧
      InterfaceAllInterfaceOperations∧
      InterfaceAllInterfaceFaults
See InterfaceRI, InterfaceKey, InterfaceParent, InterfaceAllExtendedInterfaces, InterfaceExtendsAcyclic, InterfaceAllInterfaceOperations, InterfaceAllInterfaceFaults.

2.2.2 XML Representation of Interface Component

<description>
  <interface
        name="xs:NCName" 
        extends="list of xs:QName"?
        styleDefault="list of xs:anyURI"? >
    <documentation />*
    [ <fault /> | <operation /> | <feature /> | <property /> ]*
  </interface>
</description>

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

2.2.2.1 name attribute information item with interface [owner element]

The name attribute information item together with the targetNamespace attribute information item of the [parent] description element information item forms the QName of the interface.

The name attribute information item has the following Infoset properties:

  • A [local name] of name

  • A [namespace name] which has no value

The type of the name attribute information item is xs:NCName.

2.2.2.2 extends attribute information item

The extends attribute information item lists the interfaces that this interface derives from.

The extends attribute information item has the following Infoset properties:

  • A [local name] of extends

  • A [namespace name] which has no value

The type of the extends attribute information item is a list of xs:QName.

2.2.2.3 styleDefault attribute information item

The styleDefault attribute information item indicates the default style (see 2.4.1.2 Operation Style) used to construct the {element declaration} properties of {interface message references} of all operations contained within the [owner element] interface .

The styleDefault attribute information item has the following Infoset properties:

  • A [local name] of styleDefault.

  • A [namespace name] which has no value.

The type of the styleDefault attribute information item is list of xs:anyURI. Its value, if present, MUST contain absolute IRIs (see [IETF RFC 3987]).†

2.2.3 Mapping Interface's XML Representation to Component Properties

The mapping from the XML Representation of the interface element information item (see 2.2.2 XML Representation of Interface Component) to the properties of the Interface component is as described in Table 2-2.


Table 2-2. Mapping from XML Representation to Interface Component Properties
Property Value
{name} The QName whose local name is actual value of the name attribute information item and whose namespace name is the actual value of the targetNamespace attribute information item of the [parent] description element information item
{extended interfaces} The set of Interface components resolved to by the values in the extends attribute information item, if any (see 2.19 QName resolution).
{interface faults} The set of Interface Fault components corresponding to the fault element information items in [children], if any.
{interface operations} The set of Interface Operation components corresponding to the operation element information items in [children], if any.
{features} The set of Feature components corresponding to the feature element information items in [children], if any.
{properties} The set of Property components corresponding to the property element information items in [children], if any.

Recall that, per 2.2.1 The Interface Component, 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.

2.3 Interface Fault

2.3.1 The Interface Fault Component

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.

Faults other than the ones described in the Interface component may also be generated at run-time, i.e. faults are an open set. The Interface component describes faults that have application level semantics, i.e. that the client or service is expected to handle, and potentially recover from, as part of the application processing logic. For example, an Interface component that accepts a credit card number may describe faults that indicate the credit card number is invalid, has been reported stolen, or has expired. The Interface component does not describe general system faults such as network failures, out of memory conditions, out of disk space conditions, invalid message formats, etc., although these faults may be generated as part of the message exchange. Such general system faults can reasonably be expected to occur in any message exchange and explicitly describing them in an Interface component is therefore uninformative.

The properties of the Interface Fault component are as follows:

InterfaceFault  [ show all ]  [ hide all ]

Let InterfaceFault be the set of all Interface Fault components:

InterfaceFault
NestedBase
name : QName
elementDeclaration : OPTIONAL[ID]
See NestedBase, QName, OPTIONAL, ID.
InterfaceFaultRI  [ show all ]  [ hide all ]

Each component referenced by an Interface Fault component must exist in the component model.

Let InterfaceFaultRI express the referential integrity constraints on the Interface Fault component:

InterfaceFaultRI
ComponentModel2
∀InterfaceFault |θInterfaceFault∈interfaceFaultComps •
      NestedBaseValid∧
      elementDeclaration⊆elementDeclIds
See ComponentModel2, InterfaceFault, NestedBaseValid.

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.

InterfaceFaultKey  [ show all ]  [ hide all ]

Let InterfaceFaultKey express the QName uniqueness constraint on the Interface Fault component:

InterfaceFaultKey
ComponentModel2
∀x, y : interfaceFaultComps |
      x.parent = y.parent∧
      x.name = y.name • x = y
See ComponentModel2.

Note:

Despite having a {name} property, Interface Fault components cannot be identified solely by their QName. Indeed, two Interface components whose {name} property value has the same namespace name, but different local names, can contain Interface Fault components with the same {name} property value. Thus, the {name} property of Interface Fault component is not sufficient to form the unique identity of an Interface Fault component. A method for uniquely identifying components is defined in A.2 Fragment Identifiers . See A.2.5 The Interface Fault Component for the definition of the fragment identifier for the Interface Fault component.

In cases where, due to an interface extending one or more other interfaces, two or more Interface Fault components have the same value for their {name} property, then the component models of those Interface Fault components MUST be equivalent (see 2.17 Equivalence of Components ). † 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 that are available in the same Interface component have the same value for their {name} properties but are not equivalent.

InterfaceFaultNameUnique  [ show all ]  [ hide all ]

Let InterfaceFaultNameUnique express the uniqueness constraint on the {name} property of an Interface Fault component among all the Interface Fault components available in an Interface component:

InterfaceFaultNameUnique
ComponentModel2
∀i : interfaceComps;
      x, y : interfaceFaultComps |
      x.id∈i.allInterfaceFaults∧
      y.id∈i.allInterfaceFaults∧
      x.name = y.name • x = y
See ComponentModel2.

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.

Note:

For the above reason, it is considered good practice to ensure, where necessary, that the local name of the {name} property of Interface Fault components within a namespace are unique, thus allowing such derivation to occur without inadvertent error.

If a type system NOT based on the XML Infoset [XML Information Set] is in use (as considered in 3.2 Using Other Schema Languages) 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.

InterfaceFaultCM  [ show all ]  [ hide all ]

Let InterfaceFaultCM be the conjunction of all the component model constraints on Interface Fault components.

InterfaceFaultCM≙
      InterfaceFaultRI∧
      InterfaceFaultKey∧
      InterfaceFaultNameUnique
See InterfaceFaultRI, InterfaceFaultKey, InterfaceFaultNameUnique.

2.3.2 XML Representation of Interface Fault Component

<description>
  <interface>
    <fault
          name="xs:NCName" 
          element="xs:QName"? >
      <documentation />*
      [ <feature /> | <property /> ]*
    </fault>
  </interface>
</description>

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

2.3.2.1 name attribute information item with fault [owner element]

The name attribute information item identifies a given fault element information item inside a given interface element information item.

The name attribute information item has the following Infoset properties:

  • A [local name] of name

  • A [namespace name] which has no value

The type of the name attribute information item is xs:NCName.

2.3.2.2 element attribute information item with fault [owner element]

The element attribute information item refers, by QName, to an Element Declaration component.

The element attribute information item has the following Infoset properties:

  • A [local name] of element .

  • A [namespace name] which has no value.

The type of the element attribute information item is xs:QName.

2.3.3 Mapping Interface Fault's XML Representation to Component Properties

The mapping from the XML Representation of the fault element information item (see 2.3.2 XML Representation of Interface Fault Component) to the properties of the Interface Fault component is as described in Table 2-3.


Table 2-3. Mapping from XML Representation to Interface Fault Component Properties
Property Value
{name} The QName whose local name is the actual value of the name attribute information item. and whose namespace name is the actual value of the targetNamespace attribute information item of the [parent] description element information item of the [parent] interface element information item.
{element declaration} The Element Declaration component from the {element declarations} property of the Description component resolved to by the value of the element attribute information item if present (see 2.19 QName resolution), otherwise empty. It is an error for the element attribute information item to have a value and for it to not resolve to an Element Declaration component from the {element declarations} property of the Description component.
{features} The set of Feature components corresponding to the feature element information items in [children], if any.
{properties} The set of Property components corresponding to the property element information items in [children], if any.
{parent} The Interface component corresponding to the interface element information item in [parent].

2.4 Interface Operation

2.4.1 The Interface Operation Component

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 {interface 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, [WSDL 2.0 Adjuncts] defines a set of such patterns and defines identifying IRIs 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:

InterfaceOperation  [ show all ]  [ hide all ]

Let InterfaceOperation be the set of all Interface Operation components:

InterfaceOperation
NestedBase
name : QName
messageExchangePattern : AbsoluteURI
interfaceMessageReferences :ℙID
interfaceFaultReferences :ℙID
style :ℙAbsoluteURI
See NestedBase, QName, AbsoluteURI, ID, Boolean.
InterfaceOperationRI  [ show all ]  [ hide all ]

Each component referenced by an Interface Operation component must exist in the component model.

Let InterfaceOperationRI express the referential integrity constraints on the Interface Operation component:

InterfaceOperationRI
ComponentModel2
∀InterfaceOperation |θInterfaceOperation∈interfaceOpComps •
      NestedBaseValid∧
      interfaceMessageReferences⊆interfaceMessageRefIds∧
      interfaceFaultReferences⊆interfaceFaultRefIds
See ComponentModel2, InterfaceOperation, NestedBaseValid.

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.

InterfaceOperationKey  [ show all ]  [ hide all ]

Let InterfaceOperationKey express the QName uniqueness constraint on the Interface Operation component:

InterfaceOperationKey
ComponentModel2
∀x, y : interfaceOpComps |
      x.parent = y.parent∧
      x.name = y.name • x = y
See ComponentModel2.

Note:

Despite having a {name} property, Interface Operation components cannot be identified solely by their QName. Indeed, two Interface components whose {name} property value has the same namespace name, but different local names, can contain Interface Operation components with the same {name} property value. Thus, the {name} property of Interface Operation components is not sufficient to form the unique identity of an Interface Operation component. A method for uniquely identifying components is defined in A.2 Fragment Identifiers . See A.2.6 The Interface Operation Component for the definition of the fragment identifier for the Interface Operation component.

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 2.17 Equivalence of Components).† 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.

InterfaceOperationNameUnique  [ show all ]  [ hide all ]

Let InterfaceOperationNameUnique express the uniqueness constraint on the {name} property of an Interface Operation component among all the Interface Operation components available in an Interface component:

InterfaceOperationNameUnique
ComponentModel2
∀i : interfaceComps;
      x, y : interfaceOpComps |
      x.id∈i.allInterfaceOperations∧
      y.id∈i.allInterfaceOperations∧
      x.name = y.name • x = y
See ComponentModel2.

  • No two Interface Operation components among all those available in the same Interface component have the same {name} property.

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.

Note:

For the above reason, it is considered good practice to ensure, where necessary, that the {name} property of Interface Operation components within a namespace are unique, thus allowing such derivation to occur without inadvertent error.

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.

InterfaceOperationParent  [ show all ]  [ hide all ]

An Interface Operation component contains nested Interface Message Reference and Interface Fault Reference components. These components MUST have the Interface Operation component as their parent.

Let InterfaceOperationParent express the constraints on the {parent} properties of the nested components of an Interface Operation component:

InterfaceOperationParent
ComponentModel2
∀io : interfaceOpComps;
      ifr : interfaceFaultRefComps;
      imr : interfaceMessageRefComps •
      ifr.id∈io.interfaceFaultReferences⇔ifr.parent = io.id∧
      imr.id∈io.interfaceMessageReferences⇔imr.parent = io.id
See ComponentModel2.
InterfaceOperationCM  [ show all ]  [ hide all ]

Let InterfaceOperationCM be the conjunction of all the component model constraints on Interface Operation components.

InterfaceOperationCM≙
      InterfaceOperationRI∧
      InterfaceOperationKey∧
      InterfaceOperationParent∧
      InterfaceOperationNameUnique
See InterfaceOperationRI, InterfaceOperationKey, InterfaceOperationParent, InterfaceOperationNameUnique.
2.4.1.1 Message Exchange Pattern

This section describes some aspects of message exchange patterns in more detail. Refer to the WSDL Version 2.0 Part 2: Adjuncts specification [WSDL 2.0 Adjuncts] for a complete discussion of the semantics of message exchange patterns in general as well as the definitions of the message exchange patterns that are predefined by WSDL 2.0.

A placeholder message is a template for an actual message as described by an Interface Message Reference component. Although a placeholder message is not itself a component, it is useful to regard it as having both a {message label} and a {direction} property which define the values of the actual Interface Message Reference component that corresponds to it. A placeholder message is also associated with some node that exchanges the message with the service. Furthermore, a placeholder message may be designated as optional in the exchange.

Node...
Node  [ show all ]  [ hide all ]

Let Node be the set of all nodes that participate in message exchanges:

[Node]
PlaceholderMessage  [ show all ]  [ hide all ]

Let PlaceholderMessage be the set of all placeholder messages:

PlaceholderMessage
messageLabel : NCName
direction : Direction
node : Node
optional : Boolean
See NCName, Direction, Node, Boolean.

A fault propagation ruleset specifies the relation between the Interface Fault Reference and Interface Message Reference components of an Interface Operation component. The WSDL Version 2.0 Part 2: Adjuncts specification [WSDL 2.0 Adjuncts] defines three fault propagation rulesets which we'll refer to as fault-replaces-message , message-triggers-fault , and no-faults . These fault propagation rulesets are used by the predefined message exchange patterns. Other message exchange patterns may define additional fault propagation rulesets.

FaultPropagationRuleset  [ show all ]  [ hide all ]

Let FaultPropagationRuleset be the set of all fault propagation rulesets:

[FaultPropagationRuleset]

Let the predefined fault propation rulesets be as follows:

messageTriggersFault : FaultPropagationRuleset
faultReplacesMessage : FaultPropagationRuleset
noFaults : FaultPropagationRuleset
messageTriggersFault≠faultReplacesMessage
faultReplacesMessage≠noFaults
noFaults≠messageTriggersFault
See FaultPropagationRuleset.

A message exchange pattern is a template for the exchange of one or more messages, and their associated faults, between the service and one or more other nodes as described by an Interface Operation component. The service and the other nodes are referred to as the participants in the exchange. A message exchange pattern consists of a sequence of one or more placeholder messages. Each placeholder message within this sequence is uniquely identified by its {message label} property. A message exchange pattern is uniquely identified by an absolute IRI which is used as the value of the {message exchange pattern} property of the Interface Operation component, and it specifies the fault propagation ruleset that its faults obey.†

MessageExchangePattern  [ show all ]  [ hide all ]

Let MessageExchangePattern be the set of all message exchange patterns:

MessageExchangePattern
messageExchangePattern : AbsoluteURI
placeholderMessages :seqPlaceholderMessage
faultPropagationRuleset : FaultPropagationRuleset
placeholderMessages≠∅
∀i1, i2 :ℤ; p1, p2 : PlaceholderMessage |
      i1↦p1∈placeholderMessages∧
      i2↦p2∈placeholderMessages •
      p1.messageLabel = p2.messageLabel⇒i1 = i2

  • Each message exchange pattern has at least one placeholder message.

  • Each placeholder message in a message exchange pattern is uniquely identified by its message label.

2.4.1.2 Operation Style

An operation style specifies additional information about an operation. For example, an operation style may define structural constraints on the element declarations of the interface message reference or interface fault components used by the operation. This additional information in no way affects the messages and faults exchanged with the service and it may therefore be safely ignored in that context. However, the additional information may be used for other purposes, for example, improved code generation. The {style} property of the Interface Operation component contains a set of zero or more IRIs that identify operation styles. An Interface Operation component MUST satisfy the specification defined by each operation style identified by its {style} property. † If no Interface Operation component can simultaneously satisfy all of the styles, the document is invalid.

If the {style} property of an Interface Operation component does have a value, then that value (a set of IRIs) specifies the rules that were used to define the element declarations (or other properties that define the message and fault contents; see 3.2 Using Other Schema Languages) of the Interface Message Reference or Interface Fault components used by the operation. Although a given operation style has the ability to constrain all input and output messages and faults of an operation, it MAY choose to constrain any combination thereof, e.g. only the messages, or only the inputs.

Please refer to the WSDL Version 2.0 Part 2: Adjuncts specification [WSDL 2.0 Adjuncts] for particular operation style definitions.

2.4.2 XML Representation of Interface Operation Component

<description>
  <interface>
    <operation
          name="xs:NCName" 
          pattern="xs:anyURI"
          style="list of xs:anyURI"? >
      <documentation />*
      [ <feature /> | <property /> | 
        [ <input /> | <output /> | <infault /> | <outfault /> ]+
      ]*
    </operation>
  </interface>
</description>

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

2.4.2.1 name attribute information item with operation [owner element]

The name attribute information item identifies a given operation element information item inside a given interface element information item.

The name attribute information item has the following Infoset properties:

  • A [local name] of name

  • A [namespace name] which has no value

The type of the name attribute information item is xs:NCName.

2.4.2.2 pattern attribute information item with operation [owner element]

The pattern attribute information item identifies the message exchange pattern a given operation uses.

The pattern attribute information item has the following Infoset properties:

  • A [local name] of pattern

  • A [namespace name] which has no value

The type of the pattern attribute information item is xs:anyURI. Its value MUST be an absolute IRI (see [IETF RFC 3987]).

2.4.2.3 style attribute information item with operation [owner element]

The style attribute information item indicates the rules that were used to construct the {element declaration} properties of the Interface Message Reference components which are members of the {interface message references} property of the [owner element] operation.

The style attribute information item has the following Infoset properties:

  • A [local name] of style

  • A [namespace name] which has no value

The type of the style attribute information item is list of xs:anyURI. Its value MUST be an absolute IRI (see [IETF RFC 3987]).

2.4.3 Mapping Interface Operation's XML Representation to Component Properties

The mapping from the XML Representation of the operation element information item (see 2.4.2 XML Representation of Interface Operation Component) to the properties of the Interface Operation component (see 2.4.1 The Interface Operation Component) is as described in Table 2-4.


Table 2-4. Mapping from XML Representation to Interface Operation Component Properties
Property Value
{name} The QName whose local name is the actual value of the name attribute information item and whose namespace name is the actual value of the targetNamespace attribute information item of the [parent] description element information item of the [parent] interface element information item.
{message exchange pattern} The actual value of the pattern attribute information item; otherwise 'http://www.w3.org/2006/01/wsdl/in-out'.
{interface message references} The set of message references corresponding to the input and output element information items in [children], if any.
{interface fault references} The set of interface fault references corresponding to the infault and outfault element information items in [children], if any.
{style} The set containing the IRIs in the actual value of the style attribute information item, if present; otherwise the set containing the IRIs in the actual value of the styleDefault attribute information item of the [parent] interface element information item, if present; otherwise empty.
{features} The set of Feature components corresponding to the feature element information items in [children], if any.
{properties} The set of Property components corresponding to the property element information items in [children], if any.
{parent} The Interface component corresponding to the interface element information item in [parent].

2.5 Interface Message Reference

2.5.1 The Interface Message Reference Component

An 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 [XML Information Set].

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 3.2 Using Other Schema Languages)) 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:

  • {message label} REQUIRED. An xs:NCName. This property identifies the role this message plays in the {message exchange pattern} of the Interface Operation component this message is contained within. The value of this property MUST match the name of a placeholder message defined by the message exchange pattern.†

  • {direction} REQUIRED. An xs:token with one of the values in or out, indicating whether the message is coming to the service or going from the service, respectively. The direction MUST be the same as the direction of the message identified by the {message label} property in the {message exchange pattern} of the Interface Operation component this is contained within.†

  • {message content model} REQUIRED. An xs:token with one of the values #any, #none, #other, or #element. A value of #any indicates that the message content is any single element. A value of #none indicates there is no message content. A value of #other indicates that the message content is described by some other extension property that references a declaration in a non-XML extension type system. A value of #element indicates that the message consists of a single element described by the global element declaration referenced by the {element declaration} property. This property is used only when the message is described using an XML based data model.

  • {element declaration} OPTIONAL. A reference to an XML element declaration in the {element declarations} property of the Description component. This element represents the content or “payload” of the message. When the {message content model} property has the value #any or #none the {element declaration} property MUST be empty.†

  • {features} OPTIONAL. A set of Feature components.

  • {properties} OPTIONAL. A set of Property components.

  • {parent} REQUIRED. The Interface Operation component that contains this component in its {interface message references} property.

Direction  [ show all ]  [ hide all ]

Let Direction be a message direction of either in or out:

Direction ::= inToken | outToken
MessageContentModel  [ show all ]  [ hide all ]

Let MessageContentModel be a message content model of either any, none, other, or element:

MessageContentModel ::= anyToken | noneToken | otherToken | elementToken
InterfaceMessageReference  [ show all ]  [ hide all ]

Let InterfaceMessageReference be the set of all Interface Message Reference components:

InterfaceMessageReference
NestedBase
messageLabel : NCName
direction : Direction
messageContentModel : MessageContentModel
elementDeclaration : OPTIONAL[ID]
messageContentModel = elementToken⇔elementDeclaration≠∅
See NestedBase, NCName, Direction, OPTIONAL, MessageContentModel, ID.

  • The message content model is element exactly when the element declaration property is defined.

InterfaceMessageReferenceRI  [ show all ]  [ hide all ]

Each component referenced by an Interface Message Reference component must exist in the component model.

Let InterfaceMessageReferenceRI express the referential integrity constraints on the Interface Message Reference component:

InterfaceMessageReferenceRI
ComponentModel2
∀InterfaceMessageReference |θInterfaceMessageReference∈interfaceMessageRefComps •
      NestedBaseValid∧
      elementDeclaration⊆elementDeclIds
See ComponentModel2, InterfaceMessageReference, NestedBaseValid.

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

InterfaceMessageReferenceKey  [ show all ]  [ hide all ]

Let InterfaceMessageReferenceKey express this uniqueness constraint on the Interface Message Reference component:

InterfaceMessageReferenceKey
ComponentModel2
∀x, y : interfaceMessageRefComps |
      x.parent = y.parent∧
      x.messageLabel = y.messageLabel • x = y
See ComponentModel2.

If a type system not based upon the XML Infoset is in use (as considered in 3.2 Using Other Schema Languages) 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.

InterfaceMessageReferenceCM  [ show all ]  [ hide all ]

Let InterfaceMessageReferenceCM be the conjunction of all the component model constraints on Interface Message Reference components.

InterfaceMessageReferenceCM≙
      InterfaceMessageReferenceRI∧
      InterfaceMessageReferenceKey
See InterfaceMessageReferenceRI, InterfaceMessageReferenceKey.

2.5.2 XML Representation of Interface Message Reference Component

<description>
  <interface>
    <operation>
      <input
            messageLabel="xs:NCName"?
            element="union of xs:QName, xs:token"? >
        <documentation />*
        [ <feature /> | <property /> ]*
      </input>
      <output
            messageLabel="xs:NCName"?
            element="union of xs:QName, xs:token"? >
        <documentation />*
        [ <feature /> | <property /> ]*
      </output>
    </operation>
  </interface>
</description>

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

2.5.2.1 messageLabel attribute information item with input or output [owner element]

The messageLabel attribute information item identifies the role of this message in the message exchange pattern of the given operation element information item.

The messageLabel attribute information item has the following Infoset properties:

  • A [local name] of messageLabel

  • A [namespace name] which has no value

The type of the messageLabel attribute information item is xs:NCName.

2.5.2.2 element attribute information item with input or output [owner element]

The element attribute information item has the following Infoset properties:

  • A [local name] of element .

  • A [namespace name] which has no value.

The type of the element attribute information item is a union of xs:QName and xs:token where the allowed token values are #any, #none, or #other.

2.5.3 Mapping Interface Message Reference's XML Representation to Component Properties

The mapping from the XML Representation of the interface message reference element information item (see 2.5.2 XML Representation of Interface Message Reference Component) to the properties of the Interface Message Reference component (see 2.5.1 The Interface Message Reference Component) is as described in Table 2-5.

Define the message exchange pattern of the element information item to be the {message exchange pattern} of the parent Interface Operation component.

Define the message direction of the element information item to be in if its local name is input and out if its local name is output .

The messageLabel attribute information item of an interface message reference element information item MUST be present if the message exchange pattern has more than one placeholder message with {direction} equal to the message direction. †

If the messageLabel attribute information item of an interface message reference element information item is present then its actual value MUST match the {message label} of some placeholder message with {direction} equal to the message direction. †

If the messageLabel attribute information item of an interface message reference element information item is absent then there MUST be a unique placeholder message with {direction} equal to the message direction. †

Define the effective message label of an interface message reference element information item to be either the actual value of the messageLabel attribute information item if it is present, or the {message label} of the unique placeholder message with {direction} equal to the message direction if the attribute information item is absent.


Table 2-5. Mapping from XML Representation to Interface Message Reference Component Properties
Property Value
{message label} The effective message label.
{direction} The message direction.
{message content model} If the element attribute information item is present and its value is a QName, then #element: otherwise the actual value of the element attribute information item, if any; otherwise #other.
{element declaration} If the element attribute information item is present and its value is a QName, then the Element Declaration component from the {element declarations} property of the Description component resolved to by the value of the element attribute information item (see 2.19 QName resolution); otherwise empty. It is an error for the element attribute information item to have a value and for it to NOT resolve to an Element Declaration from the {element declarations} property of the Description.
{features} The set of Feature components corresponding to the feature element information items in [children], if any.
{properties} The set of Property components corresponding to the property element information items in [children], if any.
{parent} The Interface Operation component corresponding to the interface element information item in [parent].

2.6 Interface Fault Reference

2.6.1 The Interface Fault Reference Component

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 3.2 Using Other Schema Languages) 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 Interface Fault Reference component uses the message label of the message the fault is associated with as a key.

The companion specification [WSDL 2.0 Adjuncts] defines several fault propagation rulesets that a given message exchange pattern may use. For the ruleset 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 ruleset 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 message exchange pattern.

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

  • {interface fault} REQUIRED. An Interface Fault component in the {interface faults} property of the [parent] Interface Operation component's [parent] Interface component, or an Interface component that it directly or indirectly extends. Identifying the Interface Fault component therefore indirectly defines the actual content or payload of the fault message.

  • {message label} REQUIRED. An xs:NCName. This property identifies the message this fault relates to among those defined in the {message exchange pattern} property of the Interface Operation component it is contained within. The value of this property MUST match the name of a placeholder message defined by the message exchange pattern.†

  • {direction} REQUIRED. A xs:token with one of the values in or out, indicating whether the fault is coming to the service or going from the service, respectively. The direction MUST be consistent with the direction implied by the fault propagation ruleset used in the message exchange pattern of the operation.† For example, if the ruleset fault-replaces-message is used, then a fault that refers to an outgoing message would have a {direction} property value of out. On the other hand, if the ruleset message-triggers-fault is used, then a fault that refers to an outgoing message would have a {direction} property value of in as the fault travels in the opposite direction of the message.

  • {features} OPTIONAL. A set of Feature components.

  • {properties} OPTIONAL. A set of Property components.

  • {parent} REQUIRED. The Interface Operation component that contains this component in its {interface fault references} property.

InterfaceFaultReference  [ show all ]  [ hide all ]

Let InterfaceFaultReference be the set of all Interface Fault Reference components:

InterfaceFaultReference
NestedBase
interfaceFault : ID
messageLabel : NCName
direction : Direction
See NestedBase, ID, NCName, Direction.
InterfaceFaultReferenceRI  [ show all ]  [ hide all ]

Each component referenced by a Interface Fault Reference component must exist in the component model.

Let InterfaceFaultReferenceRI express the referential integrity constraints on the Interface Fault Reference component:

InterfaceFaultReferenceRI
ComponentModel2
∀InterfaceFaultReference |θInterfaceFaultReference∈interfaceFaultRefComps •
      NestedBaseValid∧
      interfaceFault∈interfaceFaultIds
See ComponentModel2, InterfaceFaultReference, NestedBaseValid.

For each Interface Fault Reference component in the {interface fault references} property of an Interface Operation component, the combination of its {interface fault} and {message label} properties MUST be unique.†

InterfaceFaultReferenceKey  [ show all ]  [ hide all ]

Let InterfaceFaultReferenceKey express this uniqueness constraint on the Interface Fault Reference component:

InterfaceFaultReferenceKey
ComponentModel2
∀x, y : interfaceFaultRefComps |
      x.parent = y.parent∧
      x.interfaceFault = y.interfaceFault∧
      x.messageLabel = y.messageLabel • x = y
See ComponentModel2.
InterfaceFaultReferenceConsistent  [ show all ]  [ hide all ]

An Interface Fault Reference component MUST refer to an Interface Fault component that is available in the associated Interface component. An Interface Fault component is available if it is contained in the Interface component or it is available in an Interface component that this Interface component extends.

Let InterfaceFaultReferenceConsistent express this consistency constraint on the Interface Fault Reference component:

InterfaceFaultReferenceConsistent
ComponentModel2
∀ifr: interfaceFaultRefComps;
      io : interfaceOpComps;
      i : interfaceComps |
      ifr.parent = io.id∧
      io.parent = i.id •
      ifr.interfaceFault∈i.allInterfaceFaults
See ComponentModel2.
InterfaceFaultReferenceCM  [ show all ]  [ hide all ]

Let InterfaceFaultReferenceCM be the conjunction of all the component model constraints on Interface Fault Reference components.

InterfaceFaultReferenceCM≙
      InterfaceFaultReferenceRI∧
      InterfaceFaultReferenceKey∧
      InterfaceFaultReferenceConsistent
See InterfaceFaultReferenceRI, InterfaceFaultReferenceKey, InterfaceFaultReferenceConsistent.

2.6.2 XML Representation of Interface Fault Reference

<description>
  <interface>
    <operation>
      <infault
            ref="xs:QName"
            messageLabel="xs:NCName"? >
        <documentation />*
        [ <feature /> | <property /> ]*
      </infault>*
      <outfault
            ref="xs:QName"
            messageLabel="xs:NCName"? >
        <documentation />*
        [ <feature /> | <property /> ]*
      </outfault>*
    </operation>
  </interface>
</description>

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

2.6.2.1 ref attribute information item with infault , or outfault [owner element]

The ref attribute information item refers to a fault component.

The ref attribute information item has the following Infoset properties:

  • A [local name] of ref

  • A [namespace name] which has no value

The type of the ref attribute information item is xs:QName.

2.6.2.2 messageLabel attribute information item with infault , or outfault [owner element]

The messageLabel attribute information item identifies the message in the message exchange pattern of the given operation element information item that is associated with this fault.

The messageLabel attribute information item has the following Infoset properties:

  • A [local name] of messageLabel

  • A [namespace name] which has no value

The type of the messageLabel attribute information item is xs:NCName.

The messageLabel attribute information item MUST be present in the XML representation of an Interface Fault Reference component with a given {direction} if the {message exchange pattern} of the parent Interface Operation component has more than one fault with that direction. Recall that the fault propagation ruleset of the {message exchange pattern} specifies the relation between faults and messages. For example, the fault-replaces-message ruleset specifies that the faults have the same direction as the messages, while the message-triggers-fault ruleset specifies that the faults have the opposite direction from the messages.

2.6.3 Mapping Interface Fault Reference's XML Representation to Component Properties

The mapping from the XML Representation of the message reference element information item (see 2.6.2 XML Representation of Interface Fault Reference) to the properties of the Interface Fault Reference component (see 2.6.1 The Interface Fault Reference Component) is as described in Table 2-6.

Define the message exchange pattern of the element information item to be the {message exchange pattern} of the parent Interface Operation component.

Define the fault direction of the element information item to be in if its local name is infault and out if its local name is outfault .

Define the message direction of the element information item to be the {direction} of the placeholder message associated with the fault as specifed by the fault propagation ruleset of the message exchange pattern.

The messageLabel attribute information item of an interface fault reference element information item MUST be present if the message exchange pattern has more than one placeholder message with {direction} equal to the message direction. †

If the messageLabel attribute information item of an interface fault reference element information item is present then its actual value MUST match the {message label} of some placeholder message with {direction} equal to the message direction. †

If the messageLabel attribute information item of an interface fault reference element information item is absent then there MUST be a unique placeholder message with {direction} equal to the message direction. †

Define the effective message label of an interface fault reference element information item to be either the actual value of the messageLabel attribute information item if it is present, or the {message label} of the unique placeholder message whose {direction} is equal to the message direction if the attribute information item is absent.


Table 2-6. Mapping from XML Representation to Interface Fault Reference Component Properties
Property Value
{interface fault} The Interface Fault component from {interface faults} property of the parent Interface component, or an Interface component that it directly or indirectly extends, with {name} equal to the actual value of the ref attribute information item.
{message label} The effective message label.
{direction} The fault direction.
{features} The set of Feature components corresponding to the feature element information items in [children], if any.
{properties} The set of Property components corresponding to the property element information items in [children], if any.
{parent} The Interface Operation component corresponding to the interface element information item in [parent].

2.7 Feature

2.7.1 The Feature Component

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 that a client that interacts with the service use that feature. Each Feature is identified by its IRI.

WSDL 2.0's Feature concept is derived from SOAP 1.2's abstract feature concept ([SOAP 1.2 Part 1: Messaging Framework]). Every SOAP 1.2 abstract feature is therefore also a WSDL 2.0 Feature. There is no need to define a separate WSDL 2.0 Feature in order to use a particular SOAP 1.2 feature. The SOAP 1.2 feature can be used directly.

The properties of the Feature component are as follows:

  • {ref} REQUIRED. An xs:anyURI. This xs:anyURI MUST be an absolute IRI as defined by [IETF RFC 3987]. † This IRI SHOULD be dereferenceable to a document that directly or indirectly defines the meaning and use of the Feature that it identifies.

  • {required} REQUIRED. An xs:boolean. If the value of this property is true, then the client MUST use the Feature that is identified by the {ref} IRI. Otherwise, the client MAY use the Feature that is identified by the {ref} IRI. In either case, if the client does use the Feature that is identified by the {ref} IRI, then the client MUST obey all semantics implied by the definition of that Feature.

  • {parent} REQUIRED. The component that contains this component in its {features} property.

Feature  [ show all ]  [ hide all ]

Let Feature be the set of all Feature components:

Feature
Identifier
ref : AbsoluteURI
required : Boolean
Parent
See AbsoluteURI, Boolean, Parent.
FeatureRI  [ show all ]  [ hide all ]

The parent of a Feature MUST be in the component model.

Let FeatureRI express this referential integrity constraint on the Feature component:

FeatureRI
ComponentModel2
∀Feature |θFeature∈featureComps •
      ParentValid
See ComponentModel2, Feature, ParentValid.

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

FeatureKey  [ show all ]  [ hide all ]

Let FeatureKey express this uniqueness constraint on the Feature component:

FeatureKey
ComponentModel2
∀x, y : featureComps |
      x.parent = y.parent∧
      x.ref = y.ref • x = y
See ComponentModel2.

  • No two Feature components contained by the same component have the same {ref} property.

FeatureCM  [ show all ]  [ hide all ]

Let FeatureCM be the conjunction of all the component model constraints on Feature components.

FeatureCM≙
      FeatureRI∧
      FeatureKey
See FeatureRI, FeatureKey.
2.7.1.1 Feature Composition Model

The set of features which are required or available for a given component consists of the combined set of ALL feature declarations applicable to that component. A feature is applicable to a component if:

  • it is asserted directly within that component, or

  • it is asserted in a containing component, or

  • it is asserted in a component referred to by the current component.

Many of the component types in the component model contain a {features} property, which is a set of Feature components. We refer to these as the declared features of the component. Furthermore, the {features} property is itself a subset of Feature components that are required or available for the given component as determined by the Feature Composition Model. We refer to these as the in-scope features of the component.

Features  [ show all ]  [ hide all ]

Let Features denote these sets of Feature components:

Features
Identifier
features :ℙID
inScopeFeatures :ℙID
features⊆inScopeFeatures
See Identifier, ID.

  • The in-scope features for a component always include the declared features for that component.

FeaturesValid  [ show all ]  [ hide all ]

The Feature components contained by a given component MUST exist in the component model and the given component MUST be their parent.

Let FeaturesValid express these validity constraints on the {features} property of a component:

FeaturesValid
ComponentModel2
Features
features⊆featureIds
∀f : featureComps •
      f.id∈features⇔f.parent = id
See ComponentModel2, Features.

  • Each Feature component contained by this component MUST exist in the component model.

  • This component MUST be the parent of the Feature components it contains.

Following these rules, the set of features applicable at each component are as follows:

If a given feature is asserted at multiple locations, then the value of that feature at a particular component is determined by the conjunction of all the constraints implied by its asserted values. If a feature is not required then it may or may not be engaged, but if a feature is required then it must be engaged. Therefore, the conjunction of a required value and a non-required value is a required value. A composed feature is required if and only if at least one of its asserted values is required. This rule may be summarized as "true trumps".

2.7.1.1.1 Example of Feature Composition Model

In the following example, the depositFunds operation on the BankService has to be used with the ISO9001 , the notarization and the secure-channel features; they are all in scope. The fact that the notarization feature is declared both in the operation and in the binding has no effect.

<description targetNamespace="http://example.com/bank"
     xmlns=http://www.w3.org/2006/01/wsdl
     xmlns:ns1="http://example.com/bank">
  <interface name="ns1:Bank">
    <!-- All implementations of this interface must be secure -->
    <feature ref="http://example.com/secure-channel"
             required="true"/>
    <operation name="withdrawFunds">
      <!-- This operation must have ACID properties -->
      <feature ref="http://example.com/transaction"
               required="true"/>
      ...
    </operation>
    <operation name="depositFunds">
      <!-- This operation requires notarization -->
      <feature ref="http://example.com/notarization"
               required="true"/>
      ...
    </operation>
  </interface>

  <binding name="ns1:BankSOAPBinding">
    <!-- This particular binding requires ISO9001
         compliance to be verifiable -->
    <feature ref="http://example.com/ISO9001"
             required="true"/>
    <!-- This binding also requires notarization -->
    <feature ref="http://example.com/notarization"
             required="true"/>
  </binding>

  <service name="ns1:BankService"
           interface="tns:Bank">
    <endpoint binding="ns1:BankSOAPBinding">
      ...
    </endpoint>
  </service>
</description>

2.7.2 XML Representation of Feature Component

<feature
      ref="xs:anyURI" 
      required="xs:boolean"? >
  <documentation />*
</feature>

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

  • A [local name] of feature

  • A [namespace name] of "http://www.w3.org/2006/01/wsdl"

  • One or more attribute information items amongst its [attributes] as follows:

  • Zero or more element information items amongst its [children], in order as follows:

    1. Zero or more documentation element information items (see 5. Documentation).

    2. Zero or more namespace-qualified element information items whose [namespace name] is NOT "http://www.w3.org/2006/01/wsdl".

2.7.2.1 ref attribute information item with feature [owner element]

The ref attribute information item specifies the IRI of the feature.

The ref attribute information item has the following Infoset properties:

  • A [local name] of ref

  • A [namespace name] which has no value

The type of the ref attribute information item is xs:anyURI .

2.7.2.2 required attribute information item with feature [owner element]

The required attribute information item specifies whether the use of the feature is mandatory or optional.

The required attribute information item has the following Infoset properties:

  • A [local name] of required

  • A [namespace name] which has no value

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

2.7.3 Mapping Feature's XML Representation to Component Properties

The mapping from the XML Representation of the feature element information item (see 2.7.2 XML Representation of Feature Component) to the properties of the Feature component (see 2.7.1 The Feature Component) is as described in Table 2-7.


Table 2-7. Mapping from XML Representation to Feature Component Properties
Property Value
{ref} The actual value of the ref attribute information item.
{required} The actual value of the required attribute information item, if present, otherwise "false".
{parent} The component corresponding to the element information item in [parent].

2.8 Property

2.8.1 The Property Component

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 IRIs precisely to allow this type of sharing.

The properties of the Property component are as follows:

  • {ref} REQUIRED. An xs:anyURI. This xs:anyURI MUST be an absolute IRI as defined by [IETF RFC 3987].† This IRI SHOULD be dereferenceable to a document that directly or indirectly defines the meaning and use of the Property that it identifies.

  • {value constraint} OPTIONAL. A reference to a Type Definition component in the {type definitions} property of the Description component constraining the value of the Property, or the token #value if the {value} property is not empty.†

  • {value} OPTIONAL. The value of the Property, an ordered list of child information items, as specified by the [children] property of element information items in [XML Information Set].

  • {parent} REQUIRED. The component that contains this component in its {properties} property.

ValueConstraint  [ show all ]  [ hide all ]

Let ValueConstraint be the set of value constraints for Property components:

ValueConstraint ::= typeDefinitionId〈〈ID〉〉| valueToken
See ID.

  • A value constraint is either a Type Definition component which defines the set of allowable values, or the token #value which indicates that the value is given by the contents of the value property of the Property component.

ElementChildren  [ show all ]  [ hide all ]

Let ElementChildren be the set of all allowable values of the [children] property of an XML Infoset element information item:

[ElementChildren]
Property  [ show all ]  [ hide all ]

Let Property be the set of all Property components:

Property
Identifier
ref : AbsoluteURI
valueConstraint : OPTIONAL[ValueConstraint]
value : OPTIONAL[ElementChildren]
Parent
valueConstraint = {valueToken}⇔value≠∅
See Identifier, AbsoluteURI, OPTIONAL, ValueConstraint, ElementChildren, Parent.

  • The value is constrained to be an explicitly given value exactly when the {value} property is defined.

PropertyRI  [ show all ]  [ hide all ]

Each component referenced by a Property component must exist in the component model.

Let PropertyRI express the referential integrity constraints on the Property component:

PropertyRI
ComponentModel2
∀Property; y : ID |θProperty∈propertyComps •
      valueConstraint = {typeDefinitionId(y)}⇒y∈typeDefIds∧
      ParentValid
See ComponentModel2, Property, ID, ParentValid.

  • If the value constraint of a Property component is a type definition, then the Type Definition component is contained in the component model.

  • The parent of each Property component is contained in the component model.

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

PropertyKey  [ show all ]  [ hide all ]

Let PropertyKey express this uniqueness constraint on the Property component:

PropertyKey
ComponentModel2
∀x, y : propertyComps |
      x.parent = y.parent∧
      x.ref = y.ref • x = y
See ComponentModel2.

  • No two Property components contained by the same component have the same {ref} property.

If a type system not based upon the XML Infoset is in use (as considered in 3.2 Using Other Schema Languages) 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.

PropertyCM  [ show all ]  [ hide all ]

Let PropertyCM be the conjunction of all the component model constraints on Property components.

PropertyCM≙
      PropertyRI∧
      PropertyKey
See PropertyRI, PropertyKey.
2.8.1.1 Property Composition Model

At runtime, the behavior of features, (SOAP) modules and bindings may be affected by the values of in-scope properties. Properties combine into a virtual “execution context” which maps property names (IRIs) to constraints. Each property IRI MAY therefore be associated with AT MOST one property constraint for a given interaction.

The set of properties which are required or available for a given component consists of the combined set of ALL property declarations applicable to that component. A property is applicable to a component if:

  • it is asserted directly within that component, or

  • it is asserted in a containing component, or

  • it is asserted in a component referred to by the current component.

Many of the component types in the component model contain a {properties} property, which is a set of Property components. We refer to these as the declared properties of the component. Furthermore, the {properties} property is itself a subset of Property components that are required or available for the given component as determined by the Property Composition Model. We refer to these as the in-scope properties of the component.

Properties  [ show all ]  [ hide all ]

Let Properties denote these sets of Property components:

Properties
Identifier
properties :ℙID
inScopeProperties :ℙID
properties⊆inScopeProperties
See Identifier, ID.

  • The in-scope properties for a component always include the declared properties for that component.

PropertiesValid  [ show all ]  [ hide all ]

The Property components contained by a given component MUST exist in the component model and the given component MUST be their parent.

Let PropertiesValid express these validity constraints on the {properties} property of a component:

PropertiesValid
ComponentModel2
Properties
properties⊆propertyIds
∀p : propertyComps •
      p.id∈properties⇔p.parent = id
See ComponentModel2, Property.

  • Each Property component contained by this component MUST exist in the component model.

  • This component MUST be the parent of the Property components it contains.

Following these rules, the set of properties applicable at each component are as follows:

Note that, in the text above, “property constraint” (or, simply, “constraint”) is used to mean EITHER a constraint inside a Property component OR a value , since value may be considered a special case of constraint .

If a given Property is asserted at multiple locations, then the value of that Property at a particular component is determined by the conjunction of all the constraints of its in-scope Property components. A Property constraint asserts that, for a given interaction, the value of a Property is either a specified value or belongs to a specified set of values. A specified value may be regarded as a singleton set, so in both cases a Property constraint corresponds to an assertion that the Property value belongs to some set. The conjunction of all the constraints associated with the in-scope properties is an assertion that the property value belongs to each of the associated sets, or equivalently, that the value belongs to the intersection of all the associated sets. If the intersection of the associated sets is empty, then the property constraints are mutually incompatible, and the composition is invalid. Therefore, the intersection of the associated sets SHOULD NOT be empty.

Note:

The reason that we phrase the requirement for a non-empty intersection as SHOULD rather than MUST, is that in general, it may be computationally difficult to determine by inspection of the type definitions that the intersection of two or more value sets is empty. Therefore, it is not a strict validity requirement that the intersection of the value sets be non-empty. An empty intersection will always result in failure of the service at run-time.

However, it is in general feasible to test specified values for either equality or membership in value sets. All specified values MUST be equal and belong to each specified value set.†

2.8.2 XML Representation of Property Component

<property
      ref="xs:anyURI" >
  <documentation />*
  [ <value /> | <constraint /> ]?
</property>

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

2.8.2.1 ref attribute information item with property [owner element]

The ref attribute information item specifies the IRI of the property. It has the following Infoset properties:

  • A [local name] of ref

  • A [namespace name] which has no value

The type of the ref attribute information item is xs:anyURI .

2.8.2.2 value element information item with property [parent]
<property>
  <value>
    xs:anyType
  </value>
</property>

The value element information item specifies the value of the property. It has the following Infoset properties:

  • A [local name] of value

  • A [namespace name] of "http://www.w3.org/2006/01/wsdl"

The type of the value element information item is xs:anyType .

2.8.2.3 constraint element information item with property [parent]
<property>
  <constraint>
    xs:QName
  </constraint>
</property>

The constraint element information item specifies a constraint on the value of the property. It has the following Infoset properties:

  • A [local name] of constraint

  • A [namespace name] of "http://www.w3.org/2006/01/wsdl"

The type of the constraint attribute information item is xs:QName .

2.8.3 Mapping Property's XML Representation to Component Properties

The mapping from the XML Representation of the property element information item (see 2.8.2 XML Representation of Property Component) to the properties of the Property component (see 2.8.1 The Property Component) is as described in Table 2-8.


Table 2-8. Mapping from XML Representation to Property Component Properties
Property Value
{ref} The actual value of the ref attribute information item.
{value constraint} If the constraint element information item is present, the Type Definition component from the {type definitions} property of the Description component resolved to by the value of the constraint element information item (see 2.19 QName resolution); otherwise, if the value element information item is present, the token #value; otherwise empty.
{value} The value of the [children] property of the value element information item, if that element is present, otherwise empty.
{parent} The component corresponding to the element information item in [parent].

2.9 Binding

2.9.1 The Binding Component

A Binding component describes a concrete message format and transmission protocol which may be used to define an endpoint (see 2.15 Endpoint). 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 reusable manner for any interface or specifically for a given interface. Furthermore, binding information MAY be specified on a per-operation basis (see 2.11.1 The Binding Operation Component) 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 [WSDL 2.0 Adjuncts] defines such bindings for SOAP 1.2 [SOAP 1.2 Part 1: Messaging Framework] and HTTP [IETF RFC 2616]. 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 that 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 [WSDL 2.0 Adjuncts]) or by directly listing each Interface 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 Interface 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 2.19 QName resolution). For instance, Endpoint components refer to bindings in this way.

The properties of the Binding component are as follows:

  • {name} REQUIRED. An xs:QName.

  • {interface} OPTIONAL. An Interface component indicating the interface for which binding information is being specified.

  • {type} REQUIRED. An xs:anyURI. This xs:anyURI MUST be an absolute IRI as defined by [IETF RFC 3987]. The value of this IRI indicates what kind of concrete binding details are contained within this Binding component. Specifications (such as [WSDL 2.0 Adjuncts] ) that define such concrete binding details MUST specify appropriate values for this property. The value of this property MAY be the namespace name of the extension elements or attributes which define those concrete binding details.

  • {binding faults} OPTIONAL. A set of Binding Fault components.

  • {binding operations} OPTIONAL. A set of Binding Operation components.

  • {features} OPTIONAL. A set of Feature components.

  • {properties} OPTIONAL. A set of Property components.

Binding  [ show all ]  [ hide all ]

Let Binding be the set of all Binding components:

Binding
Base
name : QName
interface : OPTIONAL[ID]
type : AbsoluteURI
bindingFaults :ℙID
bindingOperations :ℙID
interface =∅⇒
      bindingFaults =∅∧
      bindingOperations =∅
See Base, QName, OPTIONAL, ID, AbsoluteURI.

  • If no Interface component is specified then there MUST NOT be any faults or operations defined.

BindingRI  [ show all ]  [ hide all ]

Each component referenced by a Binding component must exist in the component model.

Let BindingRI express the referential integrity constraints on the Binding component:

BindingRI
ComponentModel2
∀Binding |θBinding∈bindingComps •
      BaseValid∧
      interface⊆interfaceIds∧
      bindingFaults⊆bindingFaultIds∧
      bindingOperations⊆bindingOpIds
See ComponentModel2, Binding, BaseValid.

  • Every Binding component satifies the base validity constraints.

  • The Interface component of each Binding component is contained in the component model.

  • The Binding Fault components of each Binding component are contained in the component model.

  • The Binding Operation components of each Binding component are contained in the component model.

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

BindingKey  [ show all ]  [ hide all ]

Let BindingKey express the QName uniqueness constraint on the Binding component:

BindingKey
ComponentModel2
∀x, y : bindingComps |
      x.name = y.name • x = y
See ComponentModel2.

  • No two Binding components have the same QName.

BindingParent  [ show all ]  [ hide all ]

A Binding component contains nested Binding Operation and Binding Fault components. These components MUST have the Binding component as their parent.

Let BindingParent express the constraints on the {parent} properties of the nested components of a Binding component:

BindingParent
ComponentModel2
∀b : bindingComps;
      bf : bindingFaultComps;
      bo : bindingOpComps •
      bf.id∈b.bindingFaults⇔bf.parent = b.id∧
      bo.id∈b.bindingOperations⇔bo.parent = b.id
See ComponentModel2.
BindingCM  [ show all ]  [ hide all ]

Let BindingCM be the conjunction of all the component model constraints on Binding components.

BindingCM≙
      BindingRI∧
      BindingKey∧
      BindingParent
See BindingRI, BindingKey, BindingParent.

2.9.2 XML Representation of Binding Component

<description>
  <binding
        name="xs:NCName" 
        interface="xs:QName"?
        type="xs:anyURI" >
    <documentation />*
    [ <fault /> | <operation /> | <feature /> | <property /> ]*
  </binding>
</description>

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

2.9.2.1 name attribute information item with binding [owner element]

The name attribute information item together with the targetNamespace attribute information item of the description element information item forms the QName of the binding.

The name attribute information item has the following Infoset properties:

  • A [local name] of name

  • A [namespace name] which has no value

The type of the name attribute information item is xs:NCName.

2.9.2.2 interface attribute information item with binding [owner element]

The interface attribute information item refers, by QName, to an Interface component.

The interface attribute information item has the following Infoset properties:

  • A [local name] of interface

  • A [namespace name] which has no value

The type of the interface attribute information item is xs:QName.

2.9.2.3 type attribute information item with binding [owner element]

The type attribute information item identifies the kind of binding details contained in the Binding component.

The type attribute information item has the following Infoset properties:

  • A [local name] of type

  • A [namespace name] which has no value

The type of the type attribute information item is xs:anyURI.

2.9.2.4 Binding extension elements

Binding extension elements are used to provide information specific to a particular binding. The semantics of such element information items are defined by the specification for those element information items. Such specifications are expected to annotate the Binding component with additional properties and specify the mapping from the XML representation to those properties.

2.9.3 Mapping Binding's XML Representation to Component Properties

The mapping from the XML Representation of the binding element information item (see 2.9.2 XML Representation of Binding Component) to the properties of the Binding component (see 2.9.1 The Binding Component) is as described in Table 2-9.


Table 2-9. Mapping from XML Representation to Binding Component Properties
Property Value
{name} The QName whose local name is the actual value of the name attribute information item and whose namespace name is the actual value of the targetNamespace attribute information item of the [parent] description element information item.
{interface} The Interface component resolved to by the actual value of the interface attribute information item (see 2.19 QName resolution), if any.
{type} The actual value of the type attribute information item.
{binding faults} The set of Binding Fault components corresponding to the fault element information items in [children], if any.
{binding operations} The set of Binding Operation components corresponding to the operation element information items in [children], if any.
{features} The set of Feature components corresponding to the feature element information items in [children], if any.
{properties} The set of Property components corresponding to the property element information items in [children], if any.

2.10 Binding Fault

2.10.1 The Binding Fault Component

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:

BindingFault  [ show all ]  [ hide all ]

Let BindingFault be the set of all Binding Fault components:

BindingFault
NestedBase
interfaceFault : ID
See NestedBase, ID.
BindingFaultRI  [