This specification intends to meet the following requirements:

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 .

This specification uses the following syntax to define outlines for messages:

In addition to Message Information Header properties , this specification uses the following properties to define messages:

These properties bind to a SOAP Envelope as follows:

This specification can be used in terms of XML Information Set (Infoset) , even though the specification uses XML 1.0 terminology. Valid Infoset for this specification is the one serializable in XML 1.0, hence the use of XML 1.0.

The term "generate" is used in relation to the various faults defined by this specification to imply that a fault is produced and no further processing SHOULD be performed. In these cases the fault SHOULD be transmitted. However, there might be reasons when a compliant implementation can choose not to transmit the fault - for example, security concerns - in these situations the service MAY choose not to transmit the fault.

In the outlines, bold text is used to indicate those parts of the message that are defined as part of this specification and are extensions to the WS-Transfer messages.

The elements defined in this specification MAY be extended at the points indicated by their outlines and schema. Implementations MAY add child elements and/or attributes at the indicated extension points but MUST NOT contradict the semantics of the parent and/or owner, respectively. If a receiver does not recognize an extension, the receiver SHOULD ignore that extension. Senders MAY indicate the presence of an extension that has to be understood through the use of a corresponding SOAP Header with a soap:mustUnderstand attribute with the value "1".

In cases where it is either desirable or necessary for the receiver of a request that has been extended to indicate that it has recognized and accepted the semantics associated with that extension, it is RECOMMENDED that the receiver add a corresponding extension to the response message. The definition of an extension SHOULD clearly specify how the extension that appears in the response correlates with that in the corresponding request.

Extension elements and attributes MUST NOT use the Web Services Fragment namespace URI.

An implementation is not compliant with this specification if it fails to satisfy one or more of the MUST or REQUIRED level requirements defined herein. A SOAP Node MUST NOT use the XML namespace identifier for this specification (listed in ) within SOAP Envelopes unless it is compliant with this specification.

Normative text within this specification takes precedence over the XML Schema and WSDL descriptions, which in turn take precedence over outlines, which in turn take precedence over examples.

All messages defined by this specification MUST conform to the WS-Addressing specifications and be sent to a Web service that is addressable by an EPR (see ).

Unless otherwise noted, all IRIs are absolute IRIs and IRI comparison MUST be performed according to section 5.3.1.

For any message defined by this specification, any OPTIONAL elements or attributes in the message MAY be used by senders of the message; however receivers of those messages MUST support those OPTIONAL elements and attributes, unless other behavior is explicitly defined by this specification.

Implementations are expected to support both UTF-8 and UTF-16 as described in XML 1.0.

Implementations of this specification MUST conform to the corrected version of WSDL as defined by the 'WSDL Correction' sections of WS-I Basic Profile 1.2 and WS-I Basic Profile 2.0 .

The XML Namespace URI that MUST be used by implementations of this specification is:

lists XML namespaces that are used in this specification. The choice of any namespace prefix is arbitrary and not semantically significant.

The working group intends to update the value of the Web Services Fragment namespace URI each time a new version of this document is published until such time that the document reaches Candidate Recommendation status. Once it has reached Candidate Recommendation status, the working group intends to maintain the value of the Web Services Fragment namespace URI that was assigned in the Candidate Recommendation unless significant changes are made that impact the implementation or break post-CR implementations of the specification. Also see http://www.w3.org/2001/tag/doc/namespaceState.html and http://www.w3.org/2005/07/13-nsuri .

The WS-Fragment Dialect is used to identify a portion of a resource representation to update. The WS-Transfer Get and Put operations have an Expression that allows a requester to specify which subset of the resource is being modified. Except in the cases listed below, the Expression MUST evaluate to a single node within the representation. This avoids any issues that might occur due to updating multiple portions of a resource within one invocation - in other words, "batching" is prohibited. There are however a few special cases that need to be taken into account:

If an Expression does evaluate to more than one node then, except for the cases listed above, the implementation MUST process only the first selected node.

For the purposes of this specification, attributes are treated as single strings - multi-value attributes are not supported.

When using the WS-Fragment Dialect, subsets of resource representations are serialized into the Get response and Put request messages. To ensure that the receiver of those messages can unambiguously parse the data into the proper XML entities, this specification defines the following rules for serializing XML fragments.

Expressions MUST evaluate to one of four possible types: a node-set, a Boolean, a Number or a String. The latter three types are the results of evaluating a computed expression. When they appear in a message they are serialized by performing the following conversion and then wrapping the result in the wsf:Value element:

A node-set is zero or more elements, attributes or text values of elements. A node-set is serialized into XML by concatenating each node and enclosing it in the wsf:Value wrapper XML element for which schema validation is suppressed. Element nodes in a node-set are serialized directly into their XML representation. For attributes and text nodes in the node-set, a wrapper element is used to enclose these values to distinguish them from other such nodes in the serialized result.

Attribute nodes in XPath are represented in the following form:

Serialization of an attribute node separates the name from the value using the following element:

The following describes additional constraints on the outline listed above:

Text nodes are serialized in the following form:

The following describes additional constraints on the outline listed above:

Given the following XML as an example document.

The result of the XPath "/a/b | /a/b/text() | /a/c/@x" would be serialized as the following:

The nodes in the node-set MAY be serialized in any order.

The namespace bindings are evaluated against any namespace declarations that are in scope where the expression appears within the SOAP message. Note that the evaluation of expressions that rely on such context dependent bindings is fragile in the face of transformations that alter namespace prefixes. Such transformations might occur during the transmission, processing, storage, or retrieval of a request. Clients that wish to isolate expressions from the effects of any changes to the namespace prefixes in the containing SOAP message are advised to construct expressions in a manner that avoids the use of namespace prefixes. For example, use an expression such as "/a[namespace-uri()='http://www.example.com']" not "/ns1:a".

To retrieve a subset of a resource a client MUST specify the WS-Fragment Dialect IRI in the wst:Get request.

The Get request message MUST be of the following form:

The following describes additional, normative constraints on the outline listed above:

If the resource accepts a Get request, it MUST reply with a response of the following form:

The following describes additional, normative constraints on the outline listed above:

Other components of the outline above are not further constrained by this specification.

To update a subset of a resource a client MUST specify the WS-Fragment IRI in the wst:Put request.

The Put request message MUST be of the following form:

The following describes additional, normative constraints on the outline listed above:

If the resource accepts a Put request, it MUST reply with a response of the following form:

There are no additional constraints beyond what WS-Transfer defines.

The following table elaborates on the expected behavior of a WS-Fragment Put request using the XPath language.

Given a resource whose schema is defined as:

Note: for the sake of clarity, some element names have a ' or " to indicate that it is a different instance of that type of element.

This specification does not extend the Delete operation defined in WS-Transfer.

This specification does not extend the Create operation defined in WS-Transfer.

In the following examples, and Expression Language definitions, the following representation of a resource is used for informational purposes:

The following shows a sample SOAP envelope containing a Get request:

The following shows the corresponding response message:

This fault MUST be generated when a service detects an unknown or unsupported Language IRI in a request message.

This fault MUST be generated when a service determines that the Language expression specified in a request does not conform to the syntax of the language specified in the Language attribute or is semantically invalid.

This fault MUST be generated when a service detects a Mode in a Put request that is not supported.

Services indicate their support for the WS-Fragment specification through the use of the Web Services Policy - Framework and Web Services Policy - Attachment specifications.

This specification defines a policy assertion (wsf:FragmentAssertion). The normative outline of this assertion is:

The following describes additional, normative constraints on the outline listed above: