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

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 [XLink 1.0]), which is identical in most respects to IRI Section 3.1 (see [IETF RFC 3987]).

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

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 expression "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 wsdl: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 implementers 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 extension 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 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 section E. Assertion Summary.

2.1.1 The Description Component

At a high 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...

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

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

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.

• No two Element Declaration components have the same {name} and {system} properties.

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

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

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.

• No two Type Definition components have the same {name} and {system} properties.

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 component. Nested components have a {parent} property that is a reference to their parent component.

TopLevelComponent...

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

Parent  [ show all ]  [ hide all ]

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

Parent
Identifier
parent : ID

See Identifier, ID.

ParentValid...

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

NestedComponent  [ show all ]  [ hide all ]

Let NestedComponent be the set of all nested components:

NestedComponent ==

raninterfaceFault∪

raninterfaceOp∪

raninterfaceMessageRef∪

raninterfaceFaultRef∪

ranbindingFault∪

ranbindingOp∪

ranbindingMessageRef∪

ranbindingFaultRef∪

ranendpoint

See Component.

ParentId...

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

See NestedComponent, ID, InterfaceFault, InterfaceOperation, InterfaceMessageReference, InterfaceFaultReference, BindingFault, BindingOperation, BindingMessageReference, BindingFaultReference, Endpoint.

The properties of the Description component are as follows:

• {interfaces} OPTIONAL. A set of Interface components.

• {bindings} OPTIONAL. A set of Binding components.

• {services} OPTIONAL. A set of Service components.

• {element declarations} OPTIONAL. A set of Element Declaration components.

• {type definitions} REQUIRED. A set of Type Definition components.

Description...

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.

stringTD......

stringTD...  [ show all ]  [ hide all ]

Let the built-in XML schema datatypes correspond to the following Type Definition components:

stringTD, booleanTD, decimalTD, floatTD, doubleTD,

durationTD, dateTimeTD, timeTD, dateTD,

gYearMonthTD, gYearTD, gMonthDayTD, gDayTD,

gMonthTD, hexBinaryTD, base64BinaryTD,

anyURITD, QNameTD, NOTATIONTD, normalizedStringTD,

tokenTD, languageTD, NMTOKENTD, NMTOKENSTD,

NameTD, NCNameTD, IDTD, IDREFTD, IDREFSTD,

ENTITYTD, ENTITIESTD, integerTD,

nonPositiveIntegerTD, negativeIntegerTD,

longTD, intTD, shortTD, byteTD,

nonNegativeIntegerTD, unsignedLongTD, unsignedIntTD,

unsignedShortTD, unsignedByteTD, positiveIntegerTD : TypeDefinition

See TypeDefinition.

BuiltInTypeDefComps...

BuiltInTypeDefComps  [ show all ]  [ hide all ]

Let BuiltInTypeDefComps be the set of all the built-in XML schema Type Definition components:

BuiltInTypeDefComps ==

{stringTD, booleanTD, decimalTD, floatTD, doubleTD,

durationTD, dateTimeTD, timeTD, dateTD,

gYearMonthTD, gYearTD, gMonthDayTD, gDayTD,

gMonthTD, hexBinaryTD, base64BinaryTD,

anyURITD, QNameTD, NOTATIONTD, normalizedStringTD,

tokenTD, languageTD, NMTOKENTD, NMTOKENSTD,

NameTD, NCNameTD, IDTD, IDREFTD, IDREFSTD,

ENTITYTD, ENTITIESTD, integerTD,

nonPositiveIntegerTD, negativeIntegerTD,

longTD, intTD, shortTD, byteTD,

nonNegativeIntegerTD, unsignedLongTD, unsignedIntTD,

unsignedShortTD, unsignedByteTD, positiveIntegerTD}

See stringTD....

XMLSchemaURI...

XMLSchemaURI  [ show all ]  [ hide all ]

Let XMLSchemaURI be the namespace URI of XML Schema:

XMLSchemaURI : AbsoluteURI

See AbsoluteURI.

Both the namespace name of the {name} property and the {system} property of each built-in datatypes is the XML Schema URI:

∀x : BuiltInTypeDefComps •

x.name.namespaceName = x.system = XMLSchemaURI

See BuiltInTypeDefComps.

BuiltInTypeDefIds...

BuiltInTypeDefIds  [ show all ]  [ hide all ]

Let BuiltInTypeDefIds be the set of ids of the built-in datatypes:

BuiltInTypeDefIds == { x : BuiltInTypeDefComps • x.id }

See BuiltInTypeDefComps.

The built-in datatypes are distinct so there are forty-four ids in total:

#BuiltInTypeDefIds = 44

DescriptionTypeDefs...

DescriptionTypeDefs  [ show all ]  [ hide all ]

The XML Schema built-in datatypes are also built into WSDL 2.0.

Let DescriptionTypeDefs express this constraint on the Description:

DescriptionTypeDefs
ComponentModel2
BuiltInTypeDefComps⊆typeDefComps

See ComponentModel2, BuiltInTypeDefComps.

DescriptionKey...

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

DescriptionCM  [ show all ]  [ hide all ]

Each component referred 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
DescriptionTypeDefs
DescriptionKey
descriptionComp.interfaces = interfaceIds
descriptionComp.bindings = bindingIds
descriptionComp.services = serviceIds
descriptionComp.elementDeclarations = elementDeclIds
descriptionComp.typeDefinitions = typeDefIds

See DescriptionTypeDefs, DescriptionKey.

• The Description component contains exactly the set of Interface components contained in the component model.

• The Description component contains exactly the set of Binding components contained in the component model.

• The Description component contains exactly the set of Service components contained in the component model.

• The Description component contains exactly the set of Element Declaration components contained in the component model.

• The Description component contains exactly the set of Type Definition components contained in the component model.

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, plus the components associated with the WSDL 2.0 documents that the initial document includes, plus the components defined by other WSDL 2.0 documents in the namespaces that the initial document 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 documents or imported namespaces. 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.17 QName resolution ).

When using the XML Schema language to describe type system components, the inclusion of Element Declaration components and Type Definition components in a Description component is governed by the rules in 3.1 Using W3C XML Schema Definition Language.

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 descriptions 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 that share a common target namespace and zero or more wsdl:import element information items 4.2 Importing Descriptions that correspond to a collection with components 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 dereferencable.^† 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 that 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.

Components that belong to imported namespaces have different target namespace values than that of the importing WSDL 2.0 document. Thus importing is the mechanism to use components from one namespace in the definition of components from another namespace.

Note that each WSDL 2.0 document or type system component of the same kind 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/ns/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/ns/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/ns/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:

     • interface element information items (see 2.2.2 XML Representation of Interface Component).

     • binding element information items (see 2.7.2 XML Representation of Binding Component).

     • service element information items (see 2.12.2 XML Representation of Service Component).

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

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.

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 in 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 directly or indirectly, together 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.15 Equivalence of Components are treated as one single component. The interface extension mechanism behaves in a similar way for all other components that can be defined inside an interface, namely Interface Fault components.

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

The properties of the Interface component are as follows:

• {name} REQUIRED. An xs:QName.

• {extended interfaces} OPTIONAL. A set of declared Interface components which this interface extends.

• {interface faults} OPTIONAL. The set of declared Interface Fault components. Note that the namespace name of the {name} property of each Interface Fault in this set is the same as the namespace name of the {name} property of this Interface component.

• {interface operations} OPTIONAL. A set of declared Interface Operation components. Note that the namespace name of the {name} property of each Interface Operation in this set is the same as the namespace name of the {name} property of this Interface component.

Interface...

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

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

• Every Interface component satisfies the base validity constraints.

• The Interface components extended by each Interface component are contained in the component model.

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

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

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

InterfaceKey...

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.

• No two Interface components have the same {name} property.

InterfaceParent...

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.

• The set of Interface Fault components contained by an Interface component is exactly the set of Interface Fault components that have that Interface component as their parent.

• The set of Interface Operation components contained by an Interface component is exactly the set of Interface Operation components that have that Interface component as their parent.

InterfaceAllExtendedInterfaces...

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

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

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.

• An Interface Operation component is available on an Interface component if it is contained by the Interface component or it is available on an Interface component that this Interface component directly or indirectly extends.

InterfaceAllInterfaceFaults...

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.

• An Interface Fault component is available on an Interface component if it is contained by the Interface component or it is available on an Interface component that this Interface component directly or indirectly extends.

InterfaceCM...

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 /> ]*
  </interface>
</description>

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

• A [local name] of interface

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

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

  • A REQUIRED name attribute information item as described below in 2.2.2.1 name attribute information item with interface [owner element].

  • An OPTIONAL extends attribute information item as described below in 2.2.2.2 extends attribute information item.

  • An OPTIONAL styleDefault attribute information item as described below in 2.2.2.3 styleDefault attribute information item.

  • Zero or more namespace qualified attribute information items whose [namespace name] is NOT "http://www.w3.org/ns/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 fault element information items 2.3.2 XML Representation of Interface Fault Component.

     • Zero or more operation element information items 2.4.2 XML Representation of Interface Operation Component.

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

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.

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

• {name} REQUIRED. An xs:QName.

• {message content model} REQUIRED. An xs:token with one of the values #any, #none, #other, or #element.^† A value of #any indicates that the fault content is any single element. A value of #none indicates there is no fault content. A value of #other indicates that the fault 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 fault consists of a single element described by the global element declaration referenced by the {element declaration} property. This property is used only when the fault is described using an XML-based data model.

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

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

InterfaceFault...

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

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.

• Every Interface Fault component satisfies the base validity constraints.

• The Element Declaration component of each Interface Fault component is contained in the component model.

For each Interface Fault component in the {interface faults} property of an Interface component, the {name} property must be unique. Note that this constraint is enforced by the normative WSDL 2.0 XML schema.

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

InterfaceFaultKey...

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.

• No two Interface Fault components contained by the same Interface component have the same {name} property.

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.15 Equivalence of Components). ^† If the Interface Fault components are equivalent then they are considered to collapse into a single component. Within the same Interface component, if two Interface Fault components are not equivalent then their {name} properties MUST NOT be equal.

InterfaceFaultNameUnique...

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.

• No two Interface Fault 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 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.

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 SHOULD be 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 extension attributes to its XML representation) to allow associating such message types with the message reference.

InterfaceFaultCM...

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="union of xs:QName, xs:token"? >
      <documentation />*
    </fault>
  </interface>
</description>

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

• A [local name] of fault

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

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

  • A REQUIRED name attribute information item as described below in 2.3.2.1 name attribute information item with fault [owner element].

  • An OPTIONAL element attribute information item as described below in 2.3.2.2 element attribute information item with fault [owner element].

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

• Zero or more element information item 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 item s whose [namespace name] is NOT " http://www.w3.org/ns/wsdl " .

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.

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:

• {name} REQUIRED. An xs:QName.

• {message exchange pattern} REQUIRED. An xs:anyURI identifying the message exchange pattern used by the operation. This xs:anyURI MUST be an absolute IRI (see [IETF RFC 3987]).^†

• {interface message references} OPTIONAL. A set of Interface Message Reference components for the ordinary messages the operation accepts or sends.

• {interface fault references} OPTIONAL. A set of Interface Fault Reference components for the fault messages the operation accepts or sends.

• {style} OPTIONAL. A set of xs:anyURIs identifying the rules that were used to construct the {element declaration} properties of {interface message references}. (See 2.4.1.2 Operation Style.) These xs:anyURIs MUST be absolute IRIs (see [IETF RFC 3986]).^†

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

InterfaceOperation...

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

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.

• Every Interface Operation component satisfies the base validity constraints.

• The Interface Message Reference components of each Interface Operation component are contained in the component model.

• The Interface Fault Reference components of each Interface Operation component are contained in the component model.

For each Interface Operation component in the {interface operations} property of an Interface component, the {name} property MUST be unique. Note that this constraint is enforced by the normative WSDL 2.0 XML schema.

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

InterfaceOperationKey...

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.

• No two Interface Operation components contained by the same Interface component have the same {name} property.

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.15 Equivalence of Components).^† If the Interface Operation components are equivalent then they are considered to collapse into a single component. Within the same Interface component, if two Interface Operation components are not equivalent then their {name} properties MUST NOT be equal.

InterfaceOperationNameUnique...

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.

For the above reason, it is considered good practice to ensure, where necessary, that the {name} property of Interface Operation components within a namespace SHOULD be 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...

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.

• The set of Interface Fault Reference components contained by an Interface Operation component is exactly the set of Interface Fault Reference components that have that Interface Operation component as their parent.

• The set of Interface Message Reference components contained by an Interface Operation component is exactly the set of Interface Message Reference components that have that Interface Operation component as their parent.

InterfaceOperationCM...

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 Web Services Description Language (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...

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 Web Services Description Language (WSDL) Version 2.0 Part 2: Adjuncts specification [WSDL 2.0 Adjuncts] defines three fault propagation rulesets which we will refer to as fault-replaces-message, message-triggers-fault, and no-faults. These three fault propagation rulesets are used by the predefined message exchange patterns defined in [WSDL 2.0 Adjuncts]. Other message exchange patterns can define additional fault propagation rulesets.

FaultPropagationRuleset...

FaultPropagationRuleset  [ show all ]  [ hide all ]

Let FaultPropagationRuleset be the set of all fault propagation rulesets:

[FaultPropagationRuleset]

Let the predefined fault propagation 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. More specifically, 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 itself uniquely identified by an absolute IRI, which is used as the value of the {message exchange pattern} property of the Interface Operation component, and which specifies the fault propagation ruleset that its faults obey.^†

MessageExchangePattern...

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.2 XML Representation of Interface Operation Component

<description>
  <interface>
    <operation
          name="xs:NCName" 
          pattern="xs:anyURI"?
          style="list of xs:anyURI"? >
      <documentation />*
      [ <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:

• A [local name] of operation

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

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

  • A REQUIRED name attribute information item as described below in 2.4.2.1 name attribute information item with operation [owner element].

  • An OPTIONAL pattern attribute information item as described below in 2.4.2.2 pattern attribute information item with operation [owner element].

  • An OPTIONAL style attribute information item as described below in 2.4.2.3 style attribute information item with operation [owner element].

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

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

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

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

     • One or more element information items from among the following, in any order:

       • Zero or more input element information items (see 2.5.2 XML Representation of Interface Message Reference Component).

       • Zero or more output element information items (see 2.5.2 XML Representation of Interface Message Reference Component).

       • Zero or more infault element information items (see 2.6.2 XML Representation of Interface Fault Reference).

       • Zero or more outfault element information items (see 2.6.2 XML Representation of Interface Fault Reference).

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

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.

2.5.1 The Interface Message Reference Component

An Interface Message Reference component defines the content, or payload, of a message exchanged in an operation. By default, the message content is defined by an XML-based type system such as XML Schema. Other type systems may be used via the WSDL 2.0 type system extension mechanism.

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 Element Declaration component 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.^†

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

Direction...

Direction  [ show all ]  [ hide all ]

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

Direction ::= inToken | outToken

MessageContentModel...

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

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

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.

• Every Interface Message Reference component satisfies the base validity constraints.

• The Element Declaration components of each Interface Message Reference component are contained in the component model.

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

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.

• No two Interface Message Reference components contained by the same Interface Operation component have the same {message label} 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 Interface Message Reference component (along with extension attributes to its XML representation) to allow associating such message types with the message reference.

InterfaceMessageReferenceCM...

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 />*
      </input>
      <output
            messageLabel="xs:NCName"?
            element="union of xs:QName, xs:token"? >
        <documentation />*
      </output>
    </operation>
  </interface>
</description>