diff --git a/pom.xml b/pom.xml
index 2136c38582b9da5a7181e742481bcfbadfefddeb..b15f6e3bdf7d0cad23c52ff816572a214033536b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -43,7 +43,6 @@
<ant-commons-net.version>1.6.5</ant-commons-net.version>
<aspectj.version>1.9.9.1</aspectj.version>
<bdmsl.api.version>4.1.1</bdmsl.api.version>
- <bouncycastle.version>1.70</bouncycastle.version>
<build.helper.maven.version>1.9.1</build.helper.maven.version>
<commons-beanutils.version>1.9.4</commons-beanutils.version>
<commons-collections.version>3.2.2</commons-collections.version>
@@ -538,16 +537,6 @@
<artifactId>spring-modules-jakarta-commons</artifactId>
<version>${spring-modules-jakarta-commons.version}</version>
</dependency>
- <!-- dependency>
- <groupId>org.bouncycastle</groupId>
- <artifactId>bcprov-jdk15on</artifactId>
- <version>${bouncycastle.version}</version>
- </dependency>
- <dependency>
- <groupId>org.bouncycastle</groupId>
- <artifactId>bcpkix-jdk15on</artifactId>
- <version>${bouncycastle.version}</version>
- </dependency -->
<dependency>
<groupId>ant</groupId>
<artifactId>ant-commons-net</artifactId>
diff --git a/smp-angular/src/app/edit/edit-resources/edit-resource.component.html b/smp-angular/src/app/edit/edit-resources/edit-resource.component.html
index 7fb96e399ac12b71c33ad311a7b16fbe0e40429a..c3e9abd5a2d79d13428c4ff30407037ed143e8da 100644
--- a/smp-angular/src/app/edit/edit-resources/edit-resource.component.html
+++ b/smp-angular/src/app/edit/edit-resources/edit-resource.component.html
@@ -31,7 +31,7 @@
></domain-member-panel>
</mat-tab>
- <mat-tab>
+ <mat-tab *ngIf="hasSubResources">
<ng-template mat-tab-label>
<smp-label icon="description" label="Subresources"></smp-label>
</ng-template>
diff --git a/smp-angular/src/app/edit/edit-resources/edit-resource.component.ts b/smp-angular/src/app/edit/edit-resources/edit-resource.component.ts
index 7c1a9af58f0f912d6169a2f76ac0d24bd5f8d8d0..155ecdf59b31f7d6f98b673ccd9e869ecdfef7ab 100644
--- a/smp-angular/src/app/edit/edit-resources/edit-resource.component.ts
+++ b/smp-angular/src/app/edit/edit-resources/edit-resource.component.ts
@@ -1,4 +1,4 @@
-import {AfterViewInit, Component, Input, OnInit, ViewChild} from '@angular/core';
+import {Component, Input, OnInit, ViewChild} from '@angular/core';
import {BeforeLeaveGuard} from "../../window/sidenav/navigation-on-leave-guard";
import {MatPaginator, PageEvent} from "@angular/material/paginator";
import {AlertMessageService} from "../../common/alert-message/alert-message.service";
@@ -195,4 +195,21 @@ export class EditResourceComponent implements OnInit, BeforeLeaveGuard {
return !this._selectedGroup;
}
+ get hasSubResources() {
+ return this.getResourceDefinition?.subresourceDefinitions?.length > 0
+ }
+
+ get getResourceDefinition(): ResourceDefinitionRo {
+
+ if (!this._selectedResource) {
+ return null;
+ }
+ if (!this._selectedDomainResourceDef) {
+ return null;
+ }
+
+ let result: ResourceDefinitionRo = this._selectedDomainResourceDef.find(def => def.identifier == this._selectedResource.resourceTypeIdentifier);
+ return result
+ }
+
}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/OasisCPPA3Extension.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/OasisCPPA3Extension.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad3936142a851e28164bffe50126b8367e089e97
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/OasisCPPA3Extension.java
@@ -0,0 +1,64 @@
+package eu.europa.ec.smp.spi;
+
+import eu.europa.ec.smp.spi.def.OasisCppaCppDocument;
+import eu.europa.ec.smp.spi.resource.ResourceDefinitionSpi;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Joze Rihtarsic
+ * @since 5.0
+ * <p>
+ * Extension implementation for handling the Oasis CPPA-cpp resources.
+ */
+@Service
+public class OasisCPPA3Extension implements ExtensionInfo {
+
+ final OasisCppaCppDocument oasisCppaCppDocument;
+
+ public OasisCPPA3Extension(OasisCppaCppDocument oasisCppaCppDocument) {
+ this.oasisCppaCppDocument = oasisCppaCppDocument;
+ }
+
+ @Override
+ public String identifier() {
+ return "edelivery-oasis-cppa3-extension";
+ }
+
+ @Override
+ public String name() {
+ return "Oasis CPPA 3.0";
+ }
+
+ @Override
+ public String description() {
+ return "The extension implements Oasis CPPA-CPP document handlers";
+ }
+
+ @Override
+ public String version() {
+ return "1.0";
+ }
+
+ @Override
+ public List<ResourceDefinitionSpi> resourceTypes() {
+ return Collections.singletonList(oasisCppaCppDocument);
+ }
+
+ @Override
+ public List<PayloadValidatorSpi> payloadValidators() {
+ return Collections.emptyList();
+ }
+
+
+ @Override
+ public String toString() {
+ return "OasisCPPA3Extension{" +
+ "identifier=" + identifier() +
+ "name=" + name() +
+ "version=" + version() +
+ '}';
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/def/OasisCppaCppDocument.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/def/OasisCppaCppDocument.java
new file mode 100644
index 0000000000000000000000000000000000000000..f919d7818133f475de5d9cede9e7b3e75a5cdc58
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/def/OasisCppaCppDocument.java
@@ -0,0 +1,73 @@
+package eu.europa.ec.smp.spi.def;
+
+import eu.europa.ec.smp.spi.handler.OasisCppa3CppHandler;
+import eu.europa.ec.smp.spi.resource.ResourceDefinitionSpi;
+import eu.europa.ec.smp.spi.resource.ResourceHandlerSpi;
+import eu.europa.ec.smp.spi.resource.SubresourceDefinitionSpi;
+import org.springframework.stereotype.Component;
+
+import java.util.Collections;
+import java.util.List;
+
+
+/**
+ * The Oasis CPPA cpp document
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+@Component
+public class OasisCppaCppDocument implements ResourceDefinitionSpi {
+
+
+ OasisCppa3CppHandler serviceGroup10Handler;
+
+ public OasisCppaCppDocument(OasisCppa3CppHandler serviceGroup10Handler) {
+ this.serviceGroup10Handler = serviceGroup10Handler;
+ }
+
+ @Override
+ public String identifier() {
+ return "edelivery-oasis-cppa-3.0-cpp";
+ }
+
+ @Override
+ public String defaultUrlSegment() {
+ return "cpp";
+ }
+
+ @Override
+ public String name() {
+ return "Oasis CPPA3 CPP document";
+ }
+
+ @Override
+ public String description() {
+ return "Oasis CPPA-CPP document";
+ }
+
+ @Override
+ public String mimeType() {
+ return "text/xml";
+ }
+
+ @Override
+ public List<SubresourceDefinitionSpi> getSuresourceSpiList() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public ResourceHandlerSpi getResourceHandler() {
+ return serviceGroup10Handler;
+ }
+
+ @Override
+ public String toString() {
+ return "OasisCppaCppDocument {" +
+ "identifier=" + identifier() +
+ "defaultUrlSegment=" + defaultUrlSegment() +
+ "name=" + name() +
+ "mimeType=" + mimeType() +
+ '}';
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/exceptions/CPPARuntimeException.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/exceptions/CPPARuntimeException.java
new file mode 100644
index 0000000000000000000000000000000000000000..906426538191f8931ddc46f942200238eb29c74e
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/exceptions/CPPARuntimeException.java
@@ -0,0 +1,20 @@
+package eu.europa.ec.smp.spi.exceptions;
+
+public class CPPARuntimeException extends RuntimeException{
+
+ public enum ErrorCode {
+ INITIALIZE_ERROR,
+ PARSE_ERROR,
+ }
+
+ final ErrorCode errorCode;
+ public CPPARuntimeException(ErrorCode code, String message) {
+ super(message);
+ this.errorCode = code;
+ }
+
+ public CPPARuntimeException(ErrorCode code, String message, Throwable cause) {
+ super(message, cause);
+ this.errorCode = code;
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/handler/AbstractHandler.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/handler/AbstractHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..796c7dbcb13baa1ecb857c6a3c5bd31eb4af58cb
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/handler/AbstractHandler.java
@@ -0,0 +1,214 @@
+package eu.europa.ec.smp.spi.handler;
+
+import eu.europa.ec.smp.spi.api.model.RequestData;
+import eu.europa.ec.smp.spi.api.model.ResourceIdentifier;
+import eu.europa.ec.smp.spi.exceptions.CPPARuntimeException;
+import eu.europa.ec.smp.spi.exceptions.ResourceException;
+import eu.europa.ec.smp.spi.resource.ResourceHandlerSpi;
+
+import gen.eu.europa.ec.ddc.api.cppa.CPP;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+import javax.xml.XMLConstants;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.validation.Validator;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+
+/**
+ * The abstract class with common methods for implementation of the ResourceHandlerSpi.
+ *
+ * @author Joze Rihtarsic
+ * @since 5.0
+ */
+public abstract class AbstractHandler implements ResourceHandlerSpi {
+
+ static final Logger LOG = LoggerFactory.getLogger(AbstractHandler.class);
+
+ private static final String DISALLOW_DOCTYPE_FEATURE = "http://apache.org/xml/features/disallow-doctype-decl";
+ private static final ThreadLocal<DocumentBuilder> threadLocalDocumentBuilder = ThreadLocal.withInitial(() -> createDocumentBuilder());
+
+ public static DocumentBuilder createDocumentBuilder() {
+ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+ factory.setNamespaceAware(true);
+ try {
+ factory.setFeature(DISALLOW_DOCTYPE_FEATURE, true);
+ } catch (ParserConfigurationException e) {
+ LOG.warn("DocumentBuilderFactory initialization error. The feature [{}] is not supported by current factory. The feature is ignored.", DISALLOW_DOCTYPE_FEATURE);
+ }
+
+ try {
+ return factory.newDocumentBuilder();
+ } catch (ParserConfigurationException ex) {
+ throw new CPPARuntimeException(CPPARuntimeException.ErrorCode.INITIALIZE_ERROR, "Can not create new XML Document builder! Error: [" + ExceptionUtils.getRootCauseMessage(ex) + "]", ex);
+ }
+ }
+
+ private static final ThreadLocal<Unmarshaller> jaxbUnmarshaller = ThreadLocal.withInitial(() -> {
+ try {
+ JAXBContext jaxbContext = JAXBContext.newInstance(CPP.class);
+ return jaxbContext.createUnmarshaller();
+ } catch (JAXBException ex) {
+ LOG.error("Error occurred while initializing JAXBContext for ServiceGroup. Cause message:" + ex, ex);
+ }
+ return null;
+ });
+
+ private static final ThreadLocal<Marshaller> jaxbMarshaller = ThreadLocal.withInitial(() -> {
+ try {
+
+ JAXBContext jaxbContext = JAXBContext.newInstance(CPP.class);
+ return jaxbContext.createMarshaller();
+ } catch (JAXBException ex) {
+ LOG.error("Error occurred while initializing JAXBContext for ServiceGroup. Cause message:" + ex, ex);
+ }
+ return null;
+ });
+
+ private static final ThreadLocal<Validator> oasisCPPAValidator = ThreadLocal.withInitial(() -> {
+ URL xsdFilePath = AbstractHandler.class.getResource("/xsd/cppa3.xsd");
+ return generateValidatorForSchema(xsdFilePath);
+ });
+
+ protected static Validator getOasisCPPAValidator() {
+ return oasisCPPAValidator.get();
+ }
+
+ public Unmarshaller getUnmarshaller() {
+ return jaxbUnmarshaller.get();
+ }
+
+ public Marshaller getMarshaller() {
+ return jaxbMarshaller.get();
+ }
+ /**
+ * Removes the current thread's ServiceGroup Unmarshaller for this thread-local variable. If this thread-local variable
+ * is subsequently read by the current thread, its value will be reinitialized by invoking its initialValue method.
+ */
+ public void destroyUnmarshaller() {
+ jaxbUnmarshaller.remove();
+ }
+
+ public void destroyMarshaller() {
+ jaxbMarshaller.remove();
+ }
+
+ public byte[] readFromInputStream(InputStream inputStream) throws IOException {
+ ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+ byte[] data = new byte[4096];
+ int nRead;
+ while ((nRead = inputStream.read(data, 0, data.length)) != -1) {
+ buffer.write(data, 0, nRead);
+ }
+ buffer.flush();
+ return buffer.toByteArray();
+ }
+
+ private static Validator generateValidatorForSchema(URL xsdFilePath) {
+ SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+ try {
+ Schema schema = schemaFactory.newSchema(xsdFilePath);
+ Validator vaInstance = schema.newValidator();
+ vaInstance.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");
+ vaInstance.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
+ return vaInstance;
+ } catch (SAXException e) {
+ throw new IllegalStateException("Unable to initialize BDX CPPA OASIS XSD schema validator.", e);
+ }
+ }
+
+ public Document parse(InputStream inputStream) throws IOException, SAXException {
+ DocumentBuilder builder = getDocumentBuilder();
+ try {
+ return builder.parse(inputStream);
+ } finally {
+ builder.reset();
+ }
+ }
+
+
+ public CPP parseNative(Document document) {
+ try {
+ return (CPP)jaxbUnmarshaller.get().unmarshal(document);
+ } catch (JAXBException ex) {
+ throw new CPPARuntimeException(CPPARuntimeException.ErrorCode.PARSE_ERROR, "Can not parse XML Document ! Error: [" + ExceptionUtils.getRootCauseMessage(ex) + "]", ex);
+ }
+ }
+
+
+ public CPP parseNative(InputStream inputStream) {
+ try {
+ DocumentBuilder db = createDocumentBuilder();
+ // just to validate DISALLOW_DOCTYPE_FEATURE parse to Document
+ Document document = db.parse(inputStream);
+ return parseNative(document);
+ } catch (SAXException | IOException ex) {
+ throw new CPPARuntimeException(CPPARuntimeException.ErrorCode.PARSE_ERROR, "Can not parse XML Document ! Error: [" + ExceptionUtils.getRootCauseMessage(ex) + "]", ex);
+ }
+ }
+
+
+ public void serializeNative(Object jaxbObject, OutputStream outputStream, boolean prettyPrint) {
+ if (jaxbObject == null) {
+ return;
+ }
+ Marshaller jaxbMarshaller = getMarshaller();
+ // Pretty Print XML
+ try {
+ if (prettyPrint) {
+ jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, prettyPrint);
+ }
+ // to remove xmlDeclaration
+ jaxbMarshaller.marshal(jaxbObject, outputStream);
+ } catch (JAXBException ex) {
+ throw new CPPARuntimeException(CPPARuntimeException.ErrorCode.PARSE_ERROR, "Error occurred while serializing the CPP document! Error: [" + ExceptionUtils.getRootCauseMessage(ex) + "]", ex);
+ }
+ }
+
+ protected DocumentBuilder getDocumentBuilder() {
+ return threadLocalDocumentBuilder.get();
+ }
+
+
+
+
+ public QName getRootElementQName(Document document) {
+ Element element = document.getDocumentElement();
+ String namespace = element.getNamespaceURI();
+ return new QName(namespace, element.getTagName());
+ }
+
+
+
+ public ResourceIdentifier getResourceIdentifier(RequestData resourceData) throws ResourceException {
+ if (resourceData == null || resourceData.getResourceIdentifier() == null || StringUtils.isEmpty(resourceData.getResourceIdentifier().getValue())) {
+ throw new ResourceException(ResourceException.ErrorCode.INVALID_PARAMETERS, "Missing resource identifier for the resource CPP ");
+ }
+ return resourceData.getResourceIdentifier();
+ }
+
+ public ResourceIdentifier getSubresourceIdentifier(RequestData resourceData) throws ResourceException {
+ if (resourceData == null || resourceData.getSubresourceIdentifier() == null || StringUtils.isEmpty(resourceData.getSubresourceIdentifier().getValue())) {
+ throw new ResourceException(ResourceException.ErrorCode.INVALID_PARAMETERS, "Missing sub-resource identifier for the resource service metadata!");
+ }
+ return resourceData.getSubresourceIdentifier();
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/handler/OasisCppa3CppHandler.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/handler/OasisCppa3CppHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cde25364f4f9d9df020d8402adf4214f481d797
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/handler/OasisCppa3CppHandler.java
@@ -0,0 +1,207 @@
+package eu.europa.ec.smp.spi.handler;
+
+import eu.europa.ec.smp.spi.api.SmpDataServiceApi;
+import eu.europa.ec.smp.spi.api.SmpIdentifierServiceApi;
+import eu.europa.ec.smp.spi.api.model.RequestData;
+import eu.europa.ec.smp.spi.api.model.ResourceIdentifier;
+import eu.europa.ec.smp.spi.api.model.ResponseData;
+import eu.europa.ec.smp.spi.exceptions.CPPARuntimeException;
+import eu.europa.ec.smp.spi.exceptions.ResourceException;
+import eu.europa.ec.smp.spi.utils.CPPUtils;
+import gen.eu.europa.ec.ddc.api.cppa.*;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StreamUtils;
+import org.xml.sax.SAXException;
+
+import javax.xml.bind.JAXBElement;
+import javax.xml.transform.stream.StreamSource;
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigInteger;
+import java.util.List;
+
+import static eu.europa.ec.smp.spi.exceptions.ResourceException.ErrorCode.*;
+
+@Component
+public class OasisCppa3CppHandler extends AbstractHandler {
+
+ private static final Logger LOG = LoggerFactory.getLogger(OasisCppa3CppHandler.class);
+
+
+ final SmpDataServiceApi smpDataApi;
+ final SmpIdentifierServiceApi smpIdentifierApi;
+
+
+ public OasisCppa3CppHandler(SmpDataServiceApi smpDataApi,
+ SmpIdentifierServiceApi smpIdentifierApi) {
+ this.smpDataApi = smpDataApi;
+ this.smpIdentifierApi = smpIdentifierApi;
+
+ }
+
+ public void generateResource(RequestData resourceData, ResponseData responseData, List<String> fields) throws ResourceException {
+
+
+ ResourceIdentifier identifier = getResourceIdentifier(resourceData);
+ CPP cpp = new CPP();
+ Certificate singCert = CPPUtils.createCertificate("sing-cert-001", "sing-keyInfo-001");
+ Certificate encCert = CPPUtils.createCertificate("enc-cert-001", "enc-keyInfo-001");
+ HTTPTransport httpTransport = CPPUtils.createHTTPTransport("eDeliverAS4EndpointId", "http://localhost:8080/domibus/msh");
+ EbMS3ChannelType channelType = CPPUtils.createEbMS3ChannelType("eDeliverAS4ChannelId", "bdxr-transport-ebms3-as4-v1p0", httpTransport);
+ PayloadProfile payloadProfile = CPPUtils.createPayloadProfileWithOnePartType("mailProfileId", "Example mail profile", "MailPart", "text/plain", BigInteger.ONE, BigInteger.valueOf(100L));
+
+ ProfileInfo profileInfo = new ProfileInfo();
+ profileInfo.setProfileIdentifier(new ProfileIdentifier());
+ profileInfo.setDescription(new Description());
+ profileInfo.getProfileIdentifier().setValue("TestProfileId");
+ profileInfo.getDescription().setValue("Test profile");
+ cpp.setProfileInfo(profileInfo);
+
+
+ // set party info
+ cpp.setPartyInfo(new PartyInfoType());
+ PartyName partyName = new PartyName();
+ partyName.setValue(identifier.getValue());
+ cpp.getPartyInfo().getPartyNames().add(partyName);
+ cpp.getPartyInfo().getPartyIds().add(CPPUtils.createPartyTypeIdType(identifier.getValue(), identifier.getScheme()));
+
+ cpp.getPartyInfo().getCertificates().add(singCert);
+ cpp.getPartyInfo().getCertificates().add(encCert);
+
+ cpp.getPartyInfo().setCertificateDefaults(CPPUtils.createCertificateDefaults(encCert, encCert));
+ cpp.getTransports().add(CPPUtils.convertHTTPTransport(httpTransport));
+ cpp.getChannels().add(CPPUtils.convertEbMS3ChannelType(channelType));
+ cpp.getPayloadProfiles().add(payloadProfile);
+
+
+ ServiceSpecification mailService = CPPUtils.createServiceSpecification("MailService", "MailSender", "MailReceiver");
+ ServiceBinding mailServiceBinding = CPPUtils.createServiceBinding("SubmitMail", null);
+ mailService.getServiceBindings().add(mailServiceBinding);
+ mailServiceBinding.getActionBindings().add(CPPUtils.createActionBinding("SubmitMailId", "SubmitMail", payloadProfile, channelType));
+
+ cpp.getServiceSpecifications().add(mailService);
+
+ try {
+ serializeNative(cpp, responseData.getOutputStream(), true);
+ } catch (CPPARuntimeException e) {
+ throw new ResourceException(PARSE_ERROR, "Can not marshal extension for service group: [" + identifier + "]. Error: " + ExceptionUtils.getRootCauseMessage(e), e);
+ }
+
+ }
+
+
+ @Override
+ public void readResource(RequestData resourceData, ResponseData responseData) throws ResourceException {
+
+ ResourceIdentifier identifier = getResourceIdentifier(resourceData);
+ if (resourceData.getResourceInputStream() == null) {
+ LOG.warn("Empty document input stream for service-group [{}]!", identifier);
+ return;
+ }
+
+ InputStream inputStream = resourceData.getResourceInputStream();
+ // reading resource multiple time make sure it can be rest
+ if (!inputStream.markSupported()) {
+ inputStream = new BufferedInputStream(inputStream);
+ }
+ inputStream.mark(Integer.MAX_VALUE - 2);
+ validateResource(resourceData);
+
+ try {
+ inputStream.reset();
+ } catch (IOException e) {
+ throw new ResourceException(PARSE_ERROR, "Can not reset input stream", e);
+ }
+
+ try {
+ StreamUtils.copy(inputStream, responseData.getOutputStream());
+ } catch (IOException e) {
+ throw new ResourceException(PARSE_ERROR, "Error occurred while copying the ServiceGroup", e);
+ }
+
+ }
+
+ @Override
+ public void storeResource(RequestData resourceData, ResponseData responseData) throws ResourceException {
+ InputStream inputStream = resourceData.getResourceInputStream();
+ // reading resource multiple time make sure it can be rest
+ if (!inputStream.markSupported()) {
+ inputStream = new BufferedInputStream(inputStream);
+ }
+
+ inputStream.mark(Integer.MAX_VALUE - 2);
+
+ CPP cppDocument = validateAndParse(resourceData);
+
+ try {
+ inputStream.reset();
+ StreamUtils.copy(inputStream, responseData.getOutputStream());
+ // need to save serviceGroup because of the update on the resource identifier values
+ //reader.serializeNative(cppDocument, responseData.getOutputStream(), true);
+ } catch (IOException e) {
+ throw new ResourceException(PARSE_ERROR, "Error occurred while copying the ServiceGroup", e);
+ }
+ }
+
+ /**
+ * Method validates service group
+ *
+ * @param resourceData the resource data
+ */
+ @Override
+ public void validateResource(RequestData resourceData) throws ResourceException {
+ validateAndParse(resourceData);
+ }
+
+ public CPP validateAndParse(RequestData resourceData) throws ResourceException {
+ // get service group identifier
+ ResourceIdentifier identifier = getResourceIdentifier(resourceData);
+ // validate by schema
+ byte[] bytearray;
+ try {
+ bytearray = readFromInputStream(resourceData.getResourceInputStream());
+ validateOasisCPPASchema(bytearray);
+ } catch (IOException ex) {
+ throw new ResourceException(INVALID_RESOURCE, "Error occurred while reading Oasis CPP document: [" + identifier + "] with error: " + ExceptionUtils.getRootCauseMessage(ex), ex);
+ }
+ // if service group
+ CPP cppDocument = parseNative(new ByteArrayInputStream(bytearray));
+ if (cppDocument.getPartyInfo() == null || cppDocument.getPartyInfo().getPartyIds().isEmpty()) {
+ throw new ResourceException(INVALID_RESOURCE, "Error occurred while validation Oasis CPP document. Missing PartyInfo/PartyId definition!");
+ }
+
+ boolean hasMatchingPartyId = false;
+ final PartyInfoType partyInfo = cppDocument.getPartyInfo();
+ for (PartyIdType partyId : partyInfo.getPartyIds()) {
+ ResourceIdentifier xmlResourceIdentifier = smpIdentifierApi.normalizeResourceIdentifier(partyId.getValue(), partyId.getType());
+ if (xmlResourceIdentifier.equals(identifier)) {
+ hasMatchingPartyId = true;
+ break;
+ }
+ }
+
+ if (!hasMatchingPartyId) {
+ // Business identifier must equal path
+ throw new ResourceException(INVALID_PARAMETERS, "Non of participant identifiers match to URL parameter [" + identifier + "]!");
+ }
+ return cppDocument;
+ }
+
+ public static void validateOasisCPPASchema(byte[] xmlBody) throws ResourceException {
+ validateOasisCPPASchema(new ByteArrayInputStream(xmlBody));
+ }
+
+ public static void validateOasisCPPASchema(InputStream xmlBody) throws ResourceException {
+
+ try {
+ getOasisCPPAValidator().validate(new StreamSource(xmlBody));
+ } catch (SAXException | IOException e) {
+ throw new ResourceException(INVALID_RESOURCE, "Error occurred while parsing Oasis CPPA3 document. Error: " + ExceptionUtils.getRootCauseMessage(e), e);
+ }
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/CPPUtils.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/CPPUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb3d9446574962c7c70d7c89d4bd27839cfae34f
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/CPPUtils.java
@@ -0,0 +1,126 @@
+package eu.europa.ec.smp.spi.utils;
+
+import gen.eu.europa.ec.ddc.api.cppa.*;
+import org.w3._2000._09.xmldsig_.KeyInfo;
+import org.w3._2000._09.xmldsig_.ObjectFactory;
+import org.w3._2000._09.xmldsig_.X509Data;
+
+import javax.xml.bind.JAXBElement;
+import java.math.BigInteger;
+
+public class CPPUtils {
+
+
+ private static final gen.eu.europa.ec.ddc.api.cppa.ObjectFactory CPPA_OBJECT_FACTORY = new gen.eu.europa.ec.ddc.api.cppa.ObjectFactory();
+
+ protected CPPUtils() {
+ }
+
+
+ public static PartyIdType createPartyTypeIdType(String identifierValue, String scheme) {
+ PartyIdType partyIdType = new PartyIdType();
+ partyIdType.setType(scheme);
+ partyIdType.setValue(identifierValue);
+ return partyIdType;
+ }
+
+ public static Certificate createCertificate(String certId, String keyInfoID) {
+ Certificate certificate = new Certificate();
+ certificate.setId(certId);
+ certificate.setKeyInfo(createCertificateKeyInfo(keyInfoID));
+ return certificate;
+ }
+
+ public static CertificateDefaults createCertificateDefaults(Certificate signingCertId, Certificate encCertId) {
+ CertificateDefaults certificateDefaults = new CertificateDefaults();
+ CertificateRefType signingRefType = new CertificateRefType();
+ signingRefType.setCertId(signingCertId);
+ certificateDefaults.setSigningCertificateRef(signingRefType);
+
+ CertificateRefType encRefType = new CertificateRefType();
+ encRefType.setCertId(encCertId);
+ certificateDefaults.setEncryptionCertificateRef(encRefType);
+
+ return certificateDefaults;
+ }
+
+ public static KeyInfo createCertificateKeyInfo(String keyInfoId) {
+ KeyInfo keyInfo = new KeyInfo();
+ keyInfo.setId(keyInfoId);
+ ObjectFactory xmldSigObjectFactory = new ObjectFactory();
+ keyInfo.getContent().add(xmldSigObjectFactory.createKeyName("cn=" + keyInfoId));
+ X509Data data = new X509Data();
+ data.getX509IssuerSerialsAndX509SKISAndX509SubjectNames().add(xmldSigObjectFactory.createX509DataX509Certificate(("Replace " + keyInfoId + " this with real certificate!").getBytes()));
+ keyInfo.getContent().add(data);
+ return keyInfo;
+ }
+
+ public static ServiceSpecification createServiceSpecification(String serviceName, String partyRole, String counterPartyRole) {
+ ServiceSpecification serviceSpecification = new ServiceSpecification();
+ serviceSpecification.setName(serviceName);
+ serviceSpecification.setPartyRole(new RoleType());
+ serviceSpecification.setCounterPartyRole(new RoleType());
+ serviceSpecification.getPartyRole().setName(partyRole);
+ serviceSpecification.getCounterPartyRole().setName(counterPartyRole);
+ return serviceSpecification;
+ }
+
+ public static ServiceBinding createServiceBinding(String service, String serviceType) {
+ ServiceBinding serviceBinding = new ServiceBinding();
+ serviceBinding.setService(new Service());
+ serviceBinding.getService().setValue(service);
+ serviceBinding.getService().setType(serviceType);
+ return serviceBinding;
+ }
+
+ public static ActionBinding createActionBinding(String actionId, String action, PayloadProfile payloadProfileId, ChannelType channelBindingId) {
+
+ ActionBinding actionBinding = new ActionBinding();
+ actionBinding.setSendOrReceive(SendOrReceiveType.SEND);
+ actionBinding.setId(actionId);
+ actionBinding.setAction(action);
+ actionBinding.getPayloadProfileIds().add(CPPA_OBJECT_FACTORY.createPayloadProfileId(payloadProfileId));
+ actionBinding.getChannelIds().add(CPPA_OBJECT_FACTORY.createChannelId(channelBindingId));
+ return actionBinding;
+ }
+
+ public static PayloadProfile createPayloadProfileWithOnePartType(String payloadProfileId, String profileDesc, String partName, String mimeType, BigInteger minOccurs, BigInteger maxOccurs) {
+ PayloadProfile mailPayloadProfile = new PayloadProfile();
+ mailPayloadProfile.setDescription(new Description());
+ mailPayloadProfile.getDescription().setValue(profileDesc);
+ mailPayloadProfile.setId(payloadProfileId);
+ PayloadPart mailPart = new PayloadPart();
+ mailPart.setPartName(partName);
+ mailPart.setMaxOccurs(maxOccurs != null ? maxOccurs.toString(10) : null);
+ mailPart.setMinOccurs(minOccurs);
+ mailPart.setMIMEContentType(mimeType);
+ mailPayloadProfile.getPayloadParts().add(mailPart);
+
+ return mailPayloadProfile;
+ }
+
+ public static JAXBElement<? extends ChannelType> convertEbMS3ChannelType(EbMS3ChannelType ebMS3ChannelType ) {
+ return CPPA_OBJECT_FACTORY.createEbMS3Channel(ebMS3ChannelType);
+ }
+ public static EbMS3ChannelType createEbMS3ChannelType(String channelId, String channelProfileCode, TransportType transportId) {
+ EbMS3ChannelType ebMS3ChannelType = new EbMS3ChannelType();
+ ebMS3ChannelType.setId(channelId);
+ ebMS3ChannelType.setTransport(transportId);
+ ebMS3ChannelType.setChannelProfile(channelProfileCode);
+ return ebMS3ChannelType;
+ }
+
+
+ public static HTTPTransport createHTTPTransport(String transportId, String endpointUrl) {
+ HTTPTransport httpTransport = new HTTPTransport();
+ httpTransport.setId(transportId);
+ httpTransport.setEndpoint(endpointUrl);
+ httpTransport.setChunkedTransferCoding(true);
+ return httpTransport;
+ }
+
+ public static JAXBElement<? extends TransportType> convertHTTPTransport(HTTPTransport transport) {
+
+ return CPPA_OBJECT_FACTORY.createHTTPTransport(transport);
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/DatatypeConverter.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/DatatypeConverter.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d9578aab3374ec3c37951e6e03f85b37f3f3c01
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/DatatypeConverter.java
@@ -0,0 +1,76 @@
+package eu.europa.ec.smp.spi.utils;
+
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import static java.time.format.DateTimeFormatter.ISO_DATE;
+import static java.time.format.DateTimeFormatter.ISO_DATE_TIME;
+
+public class DatatypeConverter {
+ @FunctionalInterface
+ private interface ConvertToOffsetDateTime {
+ OffsetDateTime method(String string);
+ }
+
+ static final Logger LOG = LoggerFactory.getLogger(DatatypeConverter.class);
+
+ private static final List<ConvertToOffsetDateTime> PARSER_FORMATS = Arrays.asList(
+ value -> OffsetDateTime.parse(value, ISO_DATE_TIME),
+ value -> {
+ LocalDateTime ldt = LocalDateTime.parse(value, ISO_DATE_TIME);
+ return ldt.atZone(ZoneId.systemDefault()).toOffsetDateTime();
+ },
+ value -> OffsetDateTime.parse(value, ISO_DATE),
+ value -> {
+ LocalDate ldt = LocalDate.parse(value, ISO_DATE);
+ return ldt.atStartOfDay(ZoneId.systemDefault()).toOffsetDateTime();
+ });
+
+ protected DatatypeConverter() {
+ }
+
+ public static OffsetDateTime parseDateTime(String value) {
+ if (StringUtils.isBlank(value)) {
+ return null;
+ }
+
+ OffsetDateTime dateTime = PARSER_FORMATS.stream()
+ .map(parser -> parseDateTime(value, parser))
+ .filter(Objects::nonNull)
+ .findFirst().orElse(null);
+
+ if (dateTime == null) {
+ LOG.warn("Can not parse date value [{}]!", value);
+ }
+ return dateTime;
+ }
+
+ private static OffsetDateTime parseDateTime(String value, ConvertToOffsetDateTime parser) {
+ // first try to pase offset
+ try {
+ return parser.method(value);
+ } catch (DateTimeParseException ex) {
+ LOG.debug("Can not parse date [{}], Error: [{}]!", value, ex.getMessage());
+ }
+ return null;
+ }
+
+ public static String printDateTime(OffsetDateTime value) {
+ return value.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME);
+ }
+
+ public static String printDate(OffsetDateTime value) {
+ return value.format(DateTimeFormatter.ISO_OFFSET_DATE);
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/xml/OffsetDateAdapter.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/xml/OffsetDateAdapter.java
new file mode 100644
index 0000000000000000000000000000000000000000..5fee91b9bd7b18be6405aa1712fa7b5974668548
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/xml/OffsetDateAdapter.java
@@ -0,0 +1,27 @@
+
+/**
+ * Purpose of the class it to provide OffsetDateTime to string and string to OffsetDateTime conversion
+ *
+ * @author Joze Rihtarsic
+ * @since 2.0
+ */
+
+package eu.europa.ec.smp.spi.utils.xml;
+
+
+import eu.europa.ec.smp.spi.utils.DatatypeConverter;
+
+import javax.xml.bind.annotation.adapters.XmlAdapter;
+import java.time.OffsetDateTime;
+
+public class OffsetDateAdapter
+ extends XmlAdapter<String, OffsetDateTime>
+{
+ public OffsetDateTime unmarshal(String value) {
+ return (DatatypeConverter.parseDateTime(value));
+ }
+
+ public String marshal(OffsetDateTime value) {
+ return (DatatypeConverter.printDate(value));
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/xml/OffsetDateTimeAdapter.java b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/xml/OffsetDateTimeAdapter.java
new file mode 100644
index 0000000000000000000000000000000000000000..c71bdeabccbba0ec721d961f580d8dd480658acd
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/java/eu/europa/ec/smp/spi/utils/xml/OffsetDateTimeAdapter.java
@@ -0,0 +1,26 @@
+
+/**
+ * Purpose of the class it to provide OffsetDateTime to string and string to OffsetDateTime conversion
+ *
+ * @author Joze Rihtarsic
+ * @since 2.0
+ */
+
+package eu.europa.ec.smp.spi.utils.xml;
+
+import eu.europa.ec.smp.spi.utils.DatatypeConverter;
+
+import javax.xml.bind.annotation.adapters.XmlAdapter;
+import java.time.OffsetDateTime;
+
+public class OffsetDateTimeAdapter
+ extends XmlAdapter<String, OffsetDateTime>
+{
+ public OffsetDateTime unmarshal(String value) {
+ return (DatatypeConverter.parseDateTime(value));
+ }
+
+ public String marshal(OffsetDateTime value) {
+ return (DatatypeConverter.printDateTime(value));
+ }
+}
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xjb/commonServiceBinding.xjb b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xjb/commonServiceBinding.xjb
new file mode 100644
index 0000000000000000000000000000000000000000..784ca547bb20ea8a291514e8504e744ec3d7b9dd
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xjb/commonServiceBinding.xjb
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<jaxb:bindings version="2.1" xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
+ xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"
+ jaxb:extensionBindingPrefixes="xjc"
+ xmlns:xs="http://www.w3.org/2001/XMLSchema">
+ <jaxb:globalBindings xmlns:xs="http://www.w3.org/2001/XMLSchema" >
+ <xjc:javaType name="java.time.OffsetDateTime" xmlType="xs:dateTime"
+ adapter="eu.europa.ec.smp.spi.utils.xml.OffsetDateTimeAdapter"
+ />
+ <xjc:javaType name="java.time.OffsetDateTime" xmlType="xs:date"
+ adapter="eu.europa.ec.smp.spi.utils.xml.OffsetDateAdapter"
+ />
+ <xjc:simple/>
+ </jaxb:globalBindings>
+</jaxb:bindings>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xjb/oasisCppa3Binding.xjb b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xjb/oasisCppa3Binding.xjb
new file mode 100644
index 0000000000000000000000000000000000000000..34d2621fdd12526f83ca718d36c8810d7b5398c9
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xjb/oasisCppa3Binding.xjb
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<jaxb:bindings version="2.1" xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
+ xmlns:xs="http://www.w3.org/2001/XMLSchema"
+>
+ <!-- bind various namespaces to dedicated packages to prevent object collision -->
+ <jaxb:bindings scd="x-schema::tns" xmlns:tns="http://docs.oasis-open.org/ebcore/ns/cppa/v3.0" >
+ <jaxb:schemaBindings>
+ <jaxb:package name="gen.eu.europa.ec.ddc.api.cppa"/>
+ </jaxb:schemaBindings>
+ </jaxb:bindings>
+
+ <!-- rename the value element -->
+ <!-- jaxb:bindings schemaLocation="../xsd/cppa3.xsd"
+ node="//xs:complexType[@name='EDIINTChannelType']/xs:complexContent/xs:extension[@base='cppa:ChannelType']/xs:sequence/xs:element[@ref='cppa:ErrorHandling']">
+ <jaxb:property name="ErrorHandling01"/>
+ </jaxb:bindings -->
+
+
+
+
+ <jaxb:bindings schemaLocation="../xsd/cppa3.xsd" node="//xs:complexType[@name='EDIINTChannelType']/xs:complexContent/xs:extension[@base='cppa:ChannelType']">
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ErrorHandling']">
+ <jaxb:property name="EdiIntErrorHandling"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ReceiptHandling']">
+ <jaxb:property name="EdiIntReceiptHandling"/>
+ </jaxb:bindings>
+ </jaxb:bindings>
+
+ <jaxb:bindings schemaLocation="../xsd/cppa3.xsd" node="//xs:complexType[@name='WSChannelType']/xs:complexContent/xs:extension[@base='cppa:ChannelType']">
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:Addressing']">
+ <jaxb:property name="WsAddressing"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ReliableMessagingBinding']">
+ <jaxb:property name="WsReliableMessagingBinding"/>
+ </jaxb:bindings>
+ </jaxb:bindings>
+
+ <jaxb:bindings schemaLocation="../xsd/cppa3.xsd" node="//xs:complexType[@name='WSSecurityBindingType']/xs:complexContent/xs:extension[@base='cppa:ChannelFeatureType']">
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:SecurityPolicy']">
+ <jaxb:property name="WsSecurityPolicy"/>
+ </jaxb:bindings>
+ </jaxb:bindings>
+
+
+ <jaxb:bindings schemaLocation="../xsd/cppa3.xsd" node="//xs:complexType[@name='ebMS2ChannelType']/xs:complexContent/xs:extension[@base='cppa:ChannelType']">
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ErrorHandling']">
+ <jaxb:property name="EbMS2ErrorHandling"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ReceiptHandling']">
+ <jaxb:property name="EbMS2ReceiptHandling"/>
+ </jaxb:bindings>
+ </jaxb:bindings>
+
+
+ <jaxb:bindings schemaLocation="../xsd/cppa3.xsd" node="//xs:complexType[@name='ebMS3ChannelType']/xs:complexContent/xs:extension[@base='cppa:WSChannelType']">
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ErrorHandling']">
+ <jaxb:property name="EbMS3ErrorHandling"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ReceiptHandling']">
+ <jaxb:property name="EbMS3ReceiptHandling"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:Compression']">
+ <jaxb:property name="EbMS3Compression"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:Bundling']">
+ <jaxb:property name="EbMS3Bundling"/>
+ </jaxb:bindings>
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:Splitting']">
+ <jaxb:property name="EbMS3Splitting"/>
+ </jaxb:bindings>
+ </jaxb:bindings>
+
+
+ <jaxb:bindings schemaLocation="../xsd/cppa3.xsd" node="//xs:element[@name='WSReliableMessagingBinding']/xs:complexType/xs:complexContent/xs:extension[@base='cppa:ReliableMessagingBindingType']">
+ <jaxb:bindings node="./xs:sequence/xs:element[@ref='cppa:ReceiptHandling']">
+ <jaxb:property name="RMReceiptHandling"/>
+ </jaxb:bindings>
+ </jaxb:bindings>
+
+ <!-- jaxb:bindings schemaLocation="../xsd/cppa3.xsd"
+ node="//xs:complexType[@name='EDIINTChannelType']/xs:complexContent/xs:extension[@base='cppa:ChannelType']/xs:sequence/xs:element[@ref='cppa:ErrorHandling']">
+ <jaxb:property name="ErrorHandling01"/>
+ </jaxb:bindings -->
+
+ <!-- bindings >
+ <bindings node="//xs:attributeGroup[@name='headerExtension']/xs:attribute[@ref='S11:mustUnderstand']">
+ <property name="S11MustUnderstand"/>
+ </bindings>
+ </bindings -->
+
+</jaxb:bindings>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/ebbp-2.0.4.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/ebbp-2.0.4.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..9dd71527ab1970d26e81f4dbc0a897b0d9e021f6
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/ebbp-2.0.4.xsd
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?>
<!--
Metadata: Owner: ebxml-bp (OASIS ebXML Business Process TC)
Product: ebxmlbp (aka ebBP)
Product Version: 2.0.4
Artifact Type: Schema
Stage: os (OASIS Standard)
Descriptive Name: None required
Revision: None
Language: en (English)
Form: xsd (schema)
Date: 20061221 (21 December 2006)
-->
<!-- OASIS takes no position regarding the validity or scope of any intellectual property or other rights that might be claimed to pertain to the implementation or use of the technology described in this document or the extent to which any license under such rights might or might not be available; neither does it represent that it has made any effort to identify any such rights. Information on OASIS's procedures with respect to rights in OASIS specifications can be found at the OASIS website. Copies of claims of rights made available for publication and any assurances of licenses to be made available, or the result of an attempt made to obtain a general license or permission for the use of such proprietary rights by implementors or users of this specification, can be obtained from the OASIS Executive Director.
OASIS invites any interested party to bring to its attention any copyrights, patents or patent applications, or other proprietary rights which may cover technology that may be required to implement this specification. Please address the information to the OASIS Executive Director.
Copyright © OASIS Open 2005, 2006. All Rights Reserved.
This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to OASIS, except as needed for the purpose of developing OASIS specifications, in which case the procedures for copyrights defined in the OASIS Intellectual Property Rights document must be followed, or as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will not be revoked by OASIS or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and OASIS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.-->
<xsd:schema xmlns="http://docs.oasis-open.org/ebxml-bp/ebbp-2.0" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xi="http://www.w3.org/2001/XInclude" targetNamespace="http://docs.oasis-open.org/ebxml-bp/ebbp-2.0" elementFormDefault="qualified" attributeFormDefault="unqualified">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="http://www.w3.org/2001/xml.xsd"/>
<xsd:element name="ProcessSpecification">
<xsd:annotation>
<xsd:documentation>Root element of a Process Specification document that has a globally
unique identity. The Process Specification element can specify the version of the
technical specification used and the process instance version related to the target
ebBP (schema).</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="ProcessSpecificationType">
<xsd:attribute name="specificationVersion" type="xsd:NMTOKEN" use="optional">
<xsd:annotation>
<xsd:documentation>Is the technical specification version of the Process Specification. Note:
This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="instanceVersion" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>Is the version of the Process Specification or
artifact instance. An example would be the Australian Wheat Board
v2.1. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:unique name="ProcessSpecification-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="ProcessSpecificationType">
<xsd:annotation>
<xsd:documentation>Type for the root element of a Process Specification
document.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="AttributeSubstitution" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="ExternalRoles" minOccurs="0"/>
<xsd:element ref="Signal" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Variable" minOccurs="0" maxOccurs="unbounded"/>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="Package" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BusinessDocument" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BusinessTransactionHead" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BinaryCollaboration" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="MultiPartyCollaboration" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BusinessCollaboration" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="OperationMapping" minOccurs="0" maxOccurs="unbounded"/>
</xsd:choice>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="uuid" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>Defines a string identification mechanism for a Process
Specificiation. The uuid is not used for the purpose of versioning, so
that even a change introduced by AttributeSubstitution (to business documents’
schemas, for example), would be marked by a new uuid.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="Package">
<xsd:annotation>
<xsd:documentation>Defines a hierarchical name scope containing reusable
elements.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="PackageType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:unique name="Package-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="PackageType">
<xsd:annotation>
<xsd:documentation>Type for a hierarchical name scope containing reusable
elements.</xsd:documentation>
</xsd:annotation>
<xsd:choice maxOccurs="unbounded">
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="AttributeSubstitution" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="ExternalRoles" minOccurs="0"/>
<xsd:element ref="Signal" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Variable" minOccurs="0" maxOccurs="unbounded"/>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element ref="Package" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BusinessDocument" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BusinessTransactionHead" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BinaryCollaboration" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="MultiPartyCollaboration" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="BusinessCollaboration" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="OperationMapping" minOccurs="0"/>
</xsd:choice>
</xsd:choice>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="parentRef" type="xsd:IDREF" use="optional">
<xsd:annotation>
<xsd:documentation>Defines the nameID reference for a Package.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="Documentation" type="DocumentationType">
<xsd:annotation>
<xsd:documentation>Defines user documentation for any element. Must be the first element
of its container. Note: The xml:lang was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="DocumentationType">
<xsd:annotation>
<xsd:documentation>Type for the user documentation for any element.</xsd:documentation>
</xsd:annotation>
<xsd:simpleContent>
<xsd:extension base="xsd:string">
<xsd:attribute name="uri" type="xsd:anyURI">
<xsd:annotation>
<xsd:documentation>Defines the address of the Documentation object. A URL
can be a URI. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute ref="xml:lang"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<!--AttributeSubstitution allowed to "edit" references (IDREFS) or other attribute values. -->
<xsd:element name="AttributeSubstitution">
<xsd:annotation>
<xsd:documentation>Attribute or document value should be used in place of some value in
an existing Process Specification. Attribute substitution could be used for document
substitution. These substititution changes were made in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="AttributeSubstitutionType"/>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="AttributeSubstitutionType">
<xsd:annotation>
<xsd:documentation>Type for the attribute or document value used for
substitution.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="nameIDRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>Is the nameID reference to the Documentation related to a
particular element.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="attributeName" type="xsd:NMTOKEN" use="required">
<xsd:annotation>
<xsd:documentation>Is the name of an attribute of any element within the scope of
the substitution set. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="value" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>Is the value, which shall replace the current value of the
attribute. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<!--Include element is replaced by XInclude's include element.
This include element is not imported into our schema, but should
be processed (and replaced by the referenced XML) prior to validation of instances-->
<xsd:element name="ExternalRoles" type="ExternalRolesType">
<xsd:annotation>
<xsd:documentation>External role element maps to the actual roles used in a Business
Collaboration (for example, an external role maps to a Business Collaboration).
Note: This element was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="ExternalRolesType">
<xsd:annotation>
<xsd:documentation>Types for the external role that maps to actual roles in a Business
Collaboration. Performs elements are needed when the values of Roles declared in a
Business Collaboration differ from the values declared with the @name attribute.
Note: This complexType was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element name="BusinessPartnerRole" minOccurs="2" maxOccurs="unbounded">
<xsd:annotation>
<xsd:documentation>Each business partner plays one or more abstract partner roles in the Business Collaboration. </xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0"/>
<xsd:element name="Performs" type="PerformsType" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
<xsd:group name="collaborationGroup">
<xsd:annotation>
<xsd:documentation>The group that includes the various types of Collaborations. Note: The Business Collaboration will replace the Binary and MultiParty
Collaboration in a future version. Note: This group was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:choice>
<xsd:element ref="BusinessTransactionActivity" minOccurs="0"/>
<xsd:element ref="CollaborationActivity" minOccurs="0"/>
<xsd:element ref="ComplexBusinessTransactionActivity" minOccurs="0"/>
<xsd:element ref="Success" minOccurs="0"/>
<xsd:element ref="Failure" minOccurs="0"/>
<xsd:element ref="Transition" minOccurs="0"/>
<xsd:element ref="Fork" minOccurs="0"/>
<xsd:element ref="Join" minOccurs="0"/>
<xsd:element ref="Decision" minOccurs="0"/>
</xsd:choice>
</xsd:group>
<xsd:element name="BinaryCollaboration" type="BinaryCollaborationType">
<xsd:annotation>
<xsd:documentation>Two roles - Defines the interaction between two top-level or abstract
partner roles. Binary Collaboration is a choreographed state of two Business
Collaboration roles. This Business Collaboration is being
deprecated.</xsd:documentation>
</xsd:annotation>
<xsd:unique name="BinaryCollaboration-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
<xsd:unique name="BinaryCollaborationRole-ID">
<xsd:selector xpath=".//Role"/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="BinaryCollaborationType">
<xsd:annotation>
<xsd:documentation>The type related to Binary Collaboration.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="Role" type="RoleType" minOccurs="2" maxOccurs="2"/>
<xsd:element ref="TimeToPerform"/>
<xsd:element ref="Start"/>
<xsd:element name="BeginsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PreCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PostCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="EndsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:group ref="collaborationGroup" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="pattern" type="xsd:anyURI">
<xsd:annotation>
<xsd:documentation>May point to the pattern on which an activity or collaboration is
based. This attribute is used only when not using the concrete BT
patterns provided.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isInnerCollaboration" type="xsd:boolean" default="false">
<xsd:annotation>
<xsd:documentation>Indicates whether or not this Business Collaboration definition
can only be used within a Collaboration Activity (as a sub collaboration) or
initiated directly by a party.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="MultiPartyCollaboration" type="MultiPartyCollaborationType">
<xsd:annotation>
<xsd:documentation>More than two roles - Defines the interaction between more than two
top-level or abstract partner roles. Binary Collaboration is a choreographed state
of more than two Business Collaboration roles. This collaboration is being
deprecated.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="MultiPartyCollaborationType">
<xsd:annotation>
<xsd:documentation>The type related to MultiParty Collaboration.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="Role" type="RoleType" minOccurs="3" maxOccurs="unbounded"/>
<xsd:element ref="TimeToPerform"/>
<xsd:element ref="Start"/>
<xsd:element name="BeginsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PreCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PostCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="EndsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:group ref="collaborationGroup" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="pattern" type="xsd:anyURI">
<xsd:annotation>
<xsd:documentation>May point to the pattern on which an activity or collaboration is
based. This attribute is used only when not using the concrete BT
patterns provided.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isInnerCollaboration" type="xsd:boolean" default="false">
<xsd:annotation>
<xsd:documentation>Indicates whether or not this Business Collaboration definition
can only be used within a Business Collaboration activity (as a sub
collaboration) or initiated directly by a party.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="BusinessCollaboration" type="BusinessCollaborationType">
<xsd:annotation>
<xsd:documentation>Two or more roles - Two or more roles - Defines the interaction
between two or more top-level or abstract partner roles. Binary Collaboration is a
choreographed state of two or more Business Collaboration roles. This element will
replace Binary and MultiParty Collaboration elements in a future
version.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="BusinessCollaborationType">
<xsd:annotation>
<xsd:documentation>The type related to Business Collaboration.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="Role" type="RoleType" minOccurs="2" maxOccurs="unbounded"/>
<xsd:element ref="TimeToPerform"/>
<xsd:element ref="Start"/>
<xsd:element name="BeginsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PreCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PostCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="EndsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:group ref="collaborationGroup" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="pattern" type="xsd:anyURI">
<xsd:annotation>
<xsd:documentation>May point to the pattern on which an activity or collaboration is
based. This attribute is used only when not using the concrete BT
patterns provided.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isInnerCollaboration" type="xsd:boolean" default="false">
<xsd:annotation>
<xsd:documentation>Indicates whether or not this Business Collaboration definition
can only be used within a Collaboration Activity (as a sub collaboration) or
initiated directly by a party.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="DocumentEnvelope" type="DocumentEnvelopeType">
<xsd:annotation>
<xsd:documentation>Conveys business information between two roles in a business
transaction. One document envelope conveys the request from the Requesting to the
Responding role and another the response from the Responding role back to the
Requesting one (where applicable).</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="DocumentEnvelopeType">
<xsd:annotation>
<xsd:documentation>The Type related to envelope that conveys business
information.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Attachment" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="businessDocumentRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>Indicates the nameID reference to the logical business
document.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isPositiveResponse" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>May evaluate to TRUE or FALSE. If TRUE, the DocumentEnvelope is
intended as a positive response to a request. The value for this parameter is
used to evaluate a Business Success or Failure of the corresponding Business
Transaction.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="documentSecurity"/>
</xsd:complexType>
<xsd:element name="BusinessDocument" type="BusinessDocumentType">
<xsd:annotation>
<xsd:documentation>A generic name of a document. A Business Document may have 0..n
Condition Expressions.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="BusinessDocumentType">
<xsd:annotation>
<xsd:documentation>The type related to a Business Document.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="ConditionExpression" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Specification" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
<xsd:element name="Attachment">
<xsd:annotation>
<xsd:documentation>An optional unstructured document associated with a Business
Document.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Specification" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attributeGroup ref="documentSecurity"/>
<xsd:attribute name="businessDocumentRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>Indicates the nameID reference to the logical business
document.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="mimeType" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>Defines the valid MIME (Multipurpose Internet Mail
Extensions) type of this Attachment. Example:
'application/pdf'.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="minOccurs" type="xsd:integer" use="optional">
<xsd:annotation>
<xsd:documentation>Defines the minimum occurrences of an Attachment. Note: This
attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="maxOccurs" type="xsd:integer" use="optional">
<xsd:annotation>
<xsd:documentation>Defines the maximum occurrences of an Attachment. Note: This
attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:unique name="Attachment-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:element name="Specification">
<xsd:annotation>
<xsd:documentation>A specification element that can associate many references to a
particular ebBP element. For example, multiple specifications associated with a
logical Business Document. Note: This element was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:attribute name="type" type="DocumentSpecificationType" use="optional" default="schema">
<xsd:annotation>
<xsd:documentation>This attribute defines the type of the Specification of the
particular ebBP element. Note: This attribute was added in
v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="location" type="xsd:anyURI" use="required">
<xsd:annotation>
<xsd:documentation>The location of the Specification of the particular ebBP
element. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="targetNamespace" type="xsd:anyURI" use="optional">
<xsd:annotation>
<xsd:documentation>The target namespace of the Specification of the particular
ebBP element. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="externalDocumentDefRef" type="xsd:normalizedString" use="optional">
<xsd:annotation>
<xsd:documentation>A name, URN or other reference that cites an external specification or reference that defines the document. This attribute was added during v2.0.1 Public Review and included in v2.0.2.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
</xsd:element>
<xsd:element name="BusinessTransactionActivity">
<xsd:annotation>
<xsd:documentation>Defines a Business Transaction Activity within a Business
Collaboration. A Business Transaction Activity is a business activity that executes
a Business Transaction. Note in v2.0, isLegallyBinding was replaced by
hasLegalIntent.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionActivityType"/>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="BusinessTransactionActivityType">
<xsd:annotation>
<xsd:documentation>The type related to a Business Transaction Activity. The
BusinessTransactionActivityType reuses previously defined Business Transactions.
Performs elements are required to bind Role values to the Requesting and Responding
activities. The older initiatingRoleIDRef attribute is removed as insufficiently
versatile. Note: This complexType was added in v2.0. </xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="BusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="TimeToPerform"/>
<xsd:element ref="Performs" minOccurs="2" maxOccurs="unbounded"/>
<xsd:element name="BeginsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PreCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="PostCondition" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="EndsWhen" type="ConditionExpressionType" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="businessTransactionRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The nameID reference for the Business Transaction. This
attribute is used to reference the Business Transaction reused by the
BusinessTransactionActivityType.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="hasLegalIntent" type="xsd:boolean" default="false">
<xsd:annotation>
<xsd:documentation>Indicates that a particular activity that could represent
a statement or commitment between trading partners, and their shared
intent. Note: This attribute was renamed to hasLegalIntent from
isLegallyBinding in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isConcurrent" type="xsd:boolean" default="true">
<xsd:annotation>
<xsd:documentation>A parameter that governs the flow of transactions. Unlike
the security and timing parameters it does not govern the internal flow
of a transaction, rather it determines whether at run-time multiple
instances of that Business Transaction Activity can be ‘open’ at the
same time within any Business Collaboration instance performed between
any two partners. isConcurrent limits the ability to execute multiple
BTA of the same BT across Business Collaboration instances (with the
same party), or within the same Business Collaboration if multiple paths
are open. As a result, when isConcurrent is set to false, the BSIs of
each party are responsible for serializing these Business Transaction
activities.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="ComplexBusinessTransactionActivity">
<xsd:annotation>
<xsd:documentation>Defines a new descriptive element that holds an embedded activity
that allows recursive embedded activities. This construct is restricted to 'black
box' visibility (i.e. the embedded activity is used for visibility only not for a
Multiparty Collaboration). The subparties in the ComplexBTA are auxiliary partners
(not constrained by the Business Collaboration). Note: The ComplexBTA and other
linking constructs replaced the onInitiation flag in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionActivityType">
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:sequence>
<xsd:element ref="ComplexBusinessTransactionActivity"/>
<xsd:element ref="StatusVisibility"/>
</xsd:sequence>
<xsd:sequence>
<xsd:element ref="BusinessTransactionActivity"/>
<xsd:element ref="StatusVisibility"/>
</xsd:sequence>
</xsd:choice>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="StatusVisibility">
<xsd:annotation>
<xsd:documentation>Information (which can be aggregated) returned by the subparties of
an embedded Business Transaction Activity or ComplexBTA for visibility purposes to
the outermost ComplexBTA. For example, a subparty (requester in an embedded BTA that
is responder in ComplexBTA) returns aggregated supplier information to the
ComplexBTA prior to the responder issuing an order response. The Status Visibility
element specifies which status values and which Document Envelope events of the
embedded processes are considered, if any, when returning the status value to the
context of the ComplexBTA. If no status values or DocumentEnvelope events can be
monitored, then both BusinessDocumentList and SubstateVisibility are omitted. Note,
this element was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:element name="BusinessDocumentList" type="BusinessDocumentValueList" minOccurs="0"/>
<xsd:element name="SubstateVisibility" type="ConditionGuardValueList" minOccurs="0"/>
<xsd:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
</xsd:element>
<xsd:element name="CollaborationActivity" type="CollaborationActivityType">
<xsd:annotation>
<xsd:documentation>The activity of performing a Business Collaboration within another
Business Collaboration.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="CollaborationActivityType">
<xsd:annotation>
<xsd:documentation>The type related to a Collaboration Activity.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="BusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Performs" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="collaborationRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The nameID reference for the Business Collaboration
performed by the Collaboration Activity.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="FromLink">
<xsd:annotation>
<xsd:documentation>A linking construct that indicates a state that can be transitioned
from in the current context (containing element). The FromLink/@fromBusinessStateRef
attribute references the state that is transitioned from by its ID value. FromLinks
can have 0..n Condition Expressions associated with them. The conditionGuard
attribute can contain status values obtained from the state pointed to by the
FromLink; matching the value governs whether a transition is made at run time. Note:
This element was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessStateLinkType">
<xsd:attribute name="fromBusinessStateRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The nameID reference of the Business State of the
link transitioned from.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="conditionGuard" type="ConditionGuardValue" use="optional">
<xsd:annotation>
<xsd:documentation>The condition that guards the transition from a
Business State.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="ToLink">
<xsd:annotation>
<xsd:documentation>A linking construct that indicates states that the current context
(containing element) can transition to. The ToLink/@toBusinessStateRef attribute
value references the state through its ID value. Completion States can have 0..n
ConditionExpressions that are checked at runtime to determine whether the transition
to a state is actually made. Note: This element was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessStateLinkType">
<xsd:attribute name="toBusinessStateRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The nameID reference of the Business State of the
link transitioned to.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="BusinessStateLinkType">
<xsd:annotation>
<xsd:documentation>The type related to the linking constructs (TO and FROM). The type
can have 0..n Condition Expression associated with it. Note: The linking
constructs on a transition replaced the onInitiation flag in v2.0. </xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0"/>
<xsd:element ref="ConditionExpression" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="ConditionExpression">
<xsd:annotation>
<xsd:documentation>An expression element that can be evaluated and provide a TRUE or
FALSE. Multiple Condition Expression languages and expressions can be used. Note:
The capability whereby multiple Condition Expression languages and expressions
can be used was expanded (as well as its use with variables) in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="ConditionExpressionType"/>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="ConditionExpressionType">
<xsd:annotation>
<xsd:documentation>The type related to the ConditionExpression element.
A BSI supports at least the XPath language, as well as the DocumentEnvelope
(expressionLanguage of ExpressionLanguageType) which is the nameID of a Document
Envelope. In previous versions, this was known as DocumentEnvelopeNotation. When
variables are used, XPath and XSLT could be beneficial. Note: This complexType was
added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attribute name="expressionLanguage" type="ExpressionLanguageType" use="required">
<xsd:annotation>
<xsd:documentation>Defines the language used for the Condition
Expression.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="expression" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>Defines the value for the Condition
Expression.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="defaultValue" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation>Allows a default value to be specified for the Condition
Expression. This default value is expressed as an xsd:string. To acquire an
xsd:boolean, an XSLT constant boolean function of TRUE or FALSE may be
used.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="Start" type="StartType">
<xsd:annotation>
<xsd:documentation>The specific Collaboration started with to traverse a path through a
graph to a Completion State.</xsd:documentation>
</xsd:annotation>
<xsd:unique name="Start-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="StartType">
<xsd:annotation>
<xsd:documentation>The type related to the Start of a specific Collaboration type within
the Collaboration Group.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="ToLink" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="optname"/>
</xsd:complexType>
<xsd:element name="Transition" type="TransitionType">
<xsd:annotation>
<xsd:documentation>A link between business states in a Business Collaboration.
Choreography is expressed as transitions between business states. Transition to the
same business state is allowed.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="TransitionType">
<xsd:annotation>
<xsd:documentation>The type related to the traverse between business
states.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="FromLink"/>
<xsd:element ref="ToLink"/>
</xsd:sequence>
<xsd:attributeGroup ref="optname"/>
</xsd:complexType>
<xsd:element name="Decision" type="DecisionType">
<xsd:annotation>
<xsd:documentation>A particular pattern of transition between business states. For
example, a choice. This is similar to a Decision in a UML activity diagram, although
precise semantics differ. One incoming link and many outgoing links, only one of
which is taken.</xsd:documentation>
</xsd:annotation>
<xsd:unique name="Decision-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="DecisionType">
<xsd:annotation>
<xsd:documentation>The type related to a Decision construct.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="FromLink"/>
<xsd:element ref="ToLink" minOccurs="2" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="optname"/>
</xsd:complexType>
<xsd:element name="Fork" type="ForkType">
<xsd:annotation>
<xsd:documentation>A choreography construct with one incoming transition and many
outgoing transitions. All outgoing transitions are considered to happen either in
parallel or, when indicated, an exclusive OR is operative.</xsd:documentation>
</xsd:annotation>
<xsd:unique name="Fork-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="ForkType">
<xsd:annotation>
<xsd:documentation>The type related to the Fork construct</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="TimeToPerform" minOccurs="0"/>
<xsd:element ref="FromLink"/>
<xsd:element ref="ToLink" minOccurs="2" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="optname"/>
<xsd:attribute name="type" use="optional" default="OR">
<xsd:annotation>
<xsd:documentation>Defines the type of Fork. OR: An OR value will mean that any
business activity pointed to by a transition coming from the fork might be
initiated. All activities may run in parallel. XOR: Only one of the possible
activities will run.</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="OR"/>
<xsd:enumeration value="XOR"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="Join" type="JoinType">
<xsd:annotation>
<xsd:documentation>A choreography construct that defines the point where one or more forked activities join.
Can define that the completion of all state occur. </xsd:documentation>
</xsd:annotation>
<xsd:unique name="Join-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="JoinType">
<xsd:annotation>
<xsd:documentation>The type related to the Join construct</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="FromLink" minOccurs="2" maxOccurs="unbounded"/>
<xsd:element ref="ToLink" minOccurs="0"/>
</xsd:sequence>
<xsd:attributeGroup ref="optname"/>
<xsd:attribute name="waitForAll" type="xsd:boolean" default="true">
<xsd:annotation>
<xsd:documentation>Indicates that all transitions coming into the Join are
executed in order for the Business Collaboration to reach the Join state
(AND-join). By default, the Join is an AND-join.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="Success" type="CompletionType">
<xsd:annotation>
<xsd:documentation>Defines a successful completion of a Collaboration as a transition
from an activity.</xsd:documentation>
</xsd:annotation>
<xsd:unique name="Success-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:element name="Failure" type="CompletionType">
<xsd:annotation>
<xsd:documentation>Defines a failure completion of a Business Collaboration as a
transition from an activity.</xsd:documentation>
</xsd:annotation>
<xsd:unique name="Failure-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="CompletionType">
<xsd:annotation>
<xsd:documentation>The type related to the Success for Failure completion of a Business
Collaboration as a transition from an activity.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="FromLink" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="optname"/>
</xsd:complexType>
<xsd:element name="BusinessAction" type="BusinessActionType" abstract="true">
<xsd:annotation>
<xsd:documentation>An abstract superclass that holds the attributes common to the
Requesting and Responding Business Activity.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="BusinessActionType">
<xsd:annotation>
<xsd:documentation>The type related to the Business Action.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attributeGroup ref="quality"/>
</xsd:complexType>
<xsd:element name="RequestingBusinessActivity" type="RequestingBusinessActivityType">
<xsd:annotation>
<xsd:documentation>A Business Action performed by the Requesting role within a Business
Transaction. </xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="RequestingBusinessActivityType">
<xsd:annotation>
<xsd:documentation>The type related to the Requesting Business
Action.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="BusinessActionType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="RespondingBusinessActivity" type="RespondingBusinessActivityType">
<xsd:annotation>
<xsd:documentation>A Business Action performed by the Responding role within a Business
Transaction.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="RespondingBusinessActivityType">
<xsd:annotation>
<xsd:documentation>The type related to the Responding Business
Action.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="BusinessActionType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="BusinessActivityType">
<xsd:annotation>
<xsd:documentation>The type related to the Business Transaction Activity or
Collaboration Activity types (and business state).</xsd:documentation>
</xsd:annotation>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
<xsd:element name="Performs">
<xsd:annotation>
<xsd:documentation>Performs elements are required whenever referencing the
RequestingBusinessActivity or RespondingBusinessActivity in a BTA or within the BTAs
of a ComplexBTA. Also Performs elements are required when the Role values in a
referring context differ from or need to be switched between the Role values in the
referenced context. (The main referring contexts for Business Collaborations are the
content models of the CollaborationActivity and ExternalRoles elements.The BTAs and
ComplexBTAs are the other referring contexts.) For example, in
a Business Collaboration between two parties is related to another Business
Collaboration (also of two parties) using a Collaboration Activity, the roles may
change for the involved parties. Those roles are traced and associated with the
parties. This functionality supports tracing and binding of roles of the Business
Collaboration across and within multiple levels of nesting. Where allowed, the Performs element may
be omitted if the actual values of Roles in the referring and referred-to context
are the same (i.e. string identical) and they match. Note: This element was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="PerformsType"/>
</xsd:complexContent>
</xsd:complexType>
<xsd:unique name="Performs-ID">
<xsd:selector xpath="."/>
<xsd:field xpath="nameID"/>
</xsd:unique>
</xsd:element>
<xsd:complexType name="PerformsType">
<xsd:annotation>
<xsd:documentation>The type related to the role binding Performs
element.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="currentRoleRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The currentRoleRef attribute defines the nameID reference of the
specific role currently used in an activity. If roles change, this name ID
reference for the currently used role is the referring role that is linked to
the referred-to role in the performsRoleRef. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="performsRoleRef" type="xsd:IDREF" use="optional">
<xsd:annotation>
<xsd:documentation>The performsRoleRef attribute defines nameID reference of the
referred-to role for the specific role used in an activity. This referred-to role is bound
to the referring role (currentRoleRef). </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="RoleType">
<xsd:annotation>
<xsd:documentation>The type related to the Role of a Business Collaboration. For
example, in a Business Collaboration, two or more top-level roles apply. The Role
Type is a global element, that allows Role elements to be defined of Role
Type.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
<xsd:element name="BusinessTransactionHead" type="BusinessTransactionBaseType" abstract="true">
<xsd:annotation>
<xsd:documentation>The abstract superclass associated with the concrete set of defined
Business Transaction patterns. A Business Transaction is a set of business
information and Business Signal exchanges amongst business partners that occurs in
an agreed upon format and sequence (as supported by the patterns). Through
the Business Transaction Head, the concrete set of BT patterns and the Data Exchange
element (which allows pattern specialization) enable business exchange through a
defined pattern. The Business Transaction Head in essence is a placeholder where the
concrete pattern is substituted (i.e. a Request-Confirm is substituted and
used). Note: The Business Transaction Head replaced
the Business Transaction element in v2.0. </xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="BusinessTransactionBaseType">
<xsd:annotation>
<xsd:documentation>The type related to the abstract superclass associated with Business
Transactions.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0"/>
<xsd:element name="RequestingRole" type="RoleType">
<xsd:annotation>
<xsd:documentation>Allows definition of the Requesting declarative role on the Business Transaction. This explicit, yet abstract, role facilitates role mapping. This element was added in v2.0.1.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="RespondingRole" type="RoleType">
<xsd:annotation>
<xsd:documentation>Allows definition of the the Responding declarative role on the Business Transaction. This explicit, yet abstract, role facilitates role mapping. This element was added in v2.0.1.</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="pattern" type="xsd:anyURI">
<xsd:annotation>
<xsd:documentation>May point to the pattern on which the Business Transaction is
based. This attribute is used only when the concrete BT
patterns provided are not used. This attribute is retained for backward compatibility. The
concrete Business Transaction patterns are also specified. This attribute is
not be used if one of the concrete, extensible (Data Exchange) or Legacy
Business Transaction (used for conversion purposes only) patterns are used.
Note: These changes were made in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isGuaranteedDeliveryRequired" type="xsd:boolean" default="false">
<xsd:annotation>
<xsd:documentation>Refers to the expectation that the underlying messaging service
used to implement the Business Transaction protocol provides guaranteed
delivery, i.e. reliable messaging.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="BusinessTransaction" type="BusinessTransactionType" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>The Business Transaction of type
BusinessTransactionType is based on the Commercial Transaction pattern. This
pattern (and the two elements that map to it) is typically a formal obligation
between parties. Historically, the Commercial Transaction (as one of the defined
patterns) has been colloquially known as the Business Transaction. Note: This
element that maps to the Commercial Transaction pattern (i.e. the complex type
BusinessTransactionType) was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="CommercialTransaction" type="BusinessTransactionType" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>The Commercial Transaction is based on the Commercial Transaction pattern. This
pattern (and the two elements that map to it) is typically a formal obligation
between parties. Historically, the Commercial Transaction (as one of the defined
patterns) has been colloquially known as the Business Transaction. Note: This
element that maps to the Commercial Transaction pattern (i.e. the complex type
BusinessTransactionType) was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="BusinessTransactionType">
<xsd:annotation>
<xsd:documentation>Either the Commercial Transaction or the Business Transaction
elements map to type BusinessTransactionType that relates to the Commercial
Transaction pattern. The type BusinessTransactionType alllows different communities
to use the Commercial Transaction pattern via the two elements that map to it -
Commercial Transaction or Business Transaction. Note: This complexType was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="RequestConfirm" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>A concrete Business Transaction Pattern where an initiating party
requests information about their status of a previous request or a Responder's
business rules. Typically no residual obligation between parties applies. For
example, an initiating party could request authorization to sell specific products
where a confirmation response is expected. Note: This concrete pattern was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RequestResponse" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>A concrete Business Transaction Pattern where there is typically no
residual obligation between the parties. The Request-Response Business Transaction
Pattern can be used when an initiating party requests information the Responding
party already has. This pattern is used when a complex set of interrelated results
are required; otherwise use Query-Response. Typically no residual obligation between
parties applies. For example, a request for price and availability. Note: This
concrete pattern was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="QueryResponse" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>A concrete Business Transaction Pattern where the Requester queries
for information the Responder already has. The response meets the specified
constraining criteria. If a complex set of interrelated results are required, use
Request-Response Business Transaction Pattern. Typically no residual obligation
between parties applies. Note: This concrete pattern was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="InformationDistribution" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>A concrete Business Transaction Pattern where an informal exchange occurs between parties. Typically no residual obligation between parties applies. No Responding Business Document (response) applies. It is important to note that in this pattern there is a Responding Business Activity and corresponding Responding Role irrespective of the fact there is not a Responding Business Document. That Responding role receives and processes (in an abstract sense) the Request. The Responding Business Activity binds the associate role to the business action. Each activity, Requesting or Responding, has roles bound and linked to it. Note: This concrete pattern was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" minOccurs="0" maxOccurs="0"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="Notification" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>A concrete Business Transaction Pattern where there is a formal information exchange between parties that may affect the previous completion of a Commercial or Business Transaction (of the BusinessTransactionType). For example, when the Notification pattern is used for the Notification of Failure Business Transaction, this involves a business message. Another example of a business notification is an Advance Ship Notice. It is important to note that in this pattern there is a Responding Business Activity and corresponding Responding Role irrespective of the fact there is not a Responding Business Document. That Responding role receives and processes (in an abstract sense) the Request. The Responding Business Activity binds the associate role to the business action. Each activity, Requesting or Responding, has roles bound and linked to it. Note: This concrete pattern was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" minOccurs="0" maxOccurs="0"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0" maxOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0" maxOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="DataExchange" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>The element is open and allows definition of other patterns
unspecified in the concrete set of Business Transaction patterns. The
DataExchange element was not constrained to support state alignment. The
semantics related to DataExchange are partner-specific and therefore left
unspecified. Note: This element was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:choice minOccurs="0" maxOccurs="2">
<xsd:element name="RequestingBusinessActivity" minOccurs="0">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity" minOccurs="0">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType" minOccurs="0"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="LegacyBusinessTransaction" substitutionGroup="BusinessTransactionHead">
<xsd:annotation>
<xsd:documentation>The previous Business Transaction (now called
LegacyBusinessTransaction) was retained for conversions only. The previous Business
Transaction element is being replaced by the Business Transaction Head abstract
superclass, BusinessTransactionBaseType and the concrete set of Business Transaction
Patterns. Note: The Business Transaction (LegacyBusinessTransaction) will be
deprecated in a future version. This element was retained in v2.0.x versions.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:complexContent>
<xsd:extension base="BusinessTransactionBaseType">
<xsd:sequence>
<xsd:element name="RequestingBusinessActivity">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RequestingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
<xsd:attribute name="retryCount" type="xsd:int"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="RespondingBusinessActivity" minOccurs="0">
<xsd:complexType>
<xsd:complexContent>
<xsd:restriction base="RespondingBusinessActivityType">
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="DocumentEnvelope" maxOccurs="unbounded"/>
<xsd:element name="ReceiptAcknowledgement" type="ReceiptAcknowledgementType"/>
<xsd:element name="ReceiptAcknowledgementException" type="ReceiptAcknowledgementExceptionType"/>
<xsd:element name="AcceptanceAcknowledgement" type="AcceptanceAcknowledgementType" minOccurs="0"/>
<xsd:element name="AcceptanceAcknowledgementException" type="AcceptanceAcknowledgementExceptionType" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean"/>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean"/>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean"/>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration"/>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:element>
<xsd:element name="Signal" type="SignalType">
<xsd:annotation>
<xsd:documentation>As a Business Action, this element defines the identification
structure for Business Signal messages to be sent to a trading partner. Note: This
element was explicitly added for Business Signals to mirror structure of the
Business Document specification. This Business Action is non-substantive. A Business
Signal is used for state alignment. Note: This element was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="SignalEnvelopeType">
<xsd:annotation>
<xsd:documentation>The type of a Signal Envelope definition that conveys Business Action
information. This type for Business Signals mirrors the
Document Envelope structure (where applicable). A Business Signal is used for state
alignment. Note: This type was added in v2.0. </xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="signalDefinitionRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The nameID reference of the Business Signal definition for the
Business Signal. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="SignalType">
<xsd:annotation>
<xsd:documentation>The type of a Signal element. A
Business Signal is used for state alignment. This construct allows specification
references (such as those used for context), and a Signal Type may have 0..n
Condition Expression. Note: This type was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element ref="Documentation" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="ConditionExpression" minOccurs="0" maxOccurs="unbounded"/>
<xsd:element ref="Specification" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
</xsd:complexType>
<xsd:complexType name="ReceiptAcknowledgementType">
<xsd:annotation>
<xsd:documentation>The type of Business Action Business Signal of positive Receipt
Acknowledgement. A Business Signal is used for
state alignment. Note: This type was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="SignalEnvelopeType">
<xsd:attribute name="isPositiveSignal" type="xsd:boolean" fixed="true">
<xsd:annotation>
<xsd:documentation>ReceiptAcknowledgementType specifies whether positive
receipt of a Business Signal is required (i.e. the Business Signal is
not an exception). Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="ReceiptAcknowledgementExceptionType">
<xsd:annotation>
<xsd:documentation>The type of a BusinessAction Business Signal of exception Receipt
Acknowledgement. A Business Signal is used for
state alignment. Note: this type was added in v2.0. </xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="SignalEnvelopeType">
<xsd:attribute name="isPositiveSignal" fixed="false">
<xsd:annotation>
<xsd:documentation>For ReceiptAcknowledgementExceptionType, specifies
whether positive receipt of a Business Signal is not allowed (i.e. the
Business Signal is an exception). Note: This attribute was added in v2.0. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="AcceptanceAcknowledgementType">
<xsd:annotation>
<xsd:documentation>The type of Business Action Business Signal of positive Acceptance
Acknowledgement. A Business Signal is used for
state alignment. Note: This type was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="SignalEnvelopeType">
<xsd:attribute name="isPositiveSignal" fixed="true">
<xsd:annotation>
<xsd:documentation>For AcceptanceAcknolwedgmentType, specifies whether
positive acceptance of a Business Signal is required (i.e. the Business
Signal is not an exception) Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="AcceptanceAcknowledgementExceptionType">
<xsd:annotation>
<xsd:documentation>The type of a BusinessAction Business Signal of exception Acceptance
Acknowledgement. A Business Signal is used for
state alignment. Note: This type was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="SignalEnvelopeType">
<xsd:attribute name="isPositiveSignal" fixed="false">
<xsd:annotation>
<xsd:documentation>For AcceptanceAcknowledgementExceptionType, specifies
whether positive acceptance of a Business Signal is not allowed (i.e.
the Business Signal is an exception). Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="GeneralExceptionType">
<xsd:annotation>
<xsd:documentation>The type of a Business Action of general exception (exceptions other
than Receipt and Acceptance Acknowledgement). During an interaction, if specified by
the parties, the general exception may be used when a party has to trigger an
exception, for example, for a general communication of catastrophic failure. A
Business Signal is typically used for state alignment. As an unforeseen event, this
type of Exception is outside of the currently defined concrete BT patterns.
Note: this type was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexContent>
<xsd:extension base="SignalEnvelopeType">
<xsd:attribute name="isPositiveSignal" fixed="false">
<xsd:annotation>
<xsd:documentation>For GeneralExceptionType, specifies whether positive
receipt of a Business Signal is not allowed (i.e. the Business Signal is
an exception). Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="TimeToPerform">
<xsd:annotation>
<xsd:documentation>The expected time available to successfully complete a specified
activity such as a substantive response to a request. The
Time To Perform could be a variable, i.e. it can be specified at different points
during the process lifecycle. Note: This element was added (previously was an attribute on specific elements) in v2.0; capabilities were also added for late binding.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="Variable" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="duration" type="xsd:duration" use="optional">
<xsd:annotation>
<xsd:documentation>The duration of the maximum amount of time between the time
at which the request is sent and the substantive response is
received. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="type" type="TimeToPerformType" use="optional" default="design">
<xsd:annotation>
<xsd:documentation>The type as specified by the simpleType of
TimeToPerformType. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
<xsd:element name="Variable">
<xsd:annotation>
<xsd:documentation>A semantic element that supports the effective use of conditional
constraints. The variable can be accessed by external elements. The
businessTransactionActivityRef and businessDocumentRef point to what context and
documents are relevant to Condition Expression evaluation. Variable assumes type, if
any, from expression evaluation. This element, for example, could be associated with
a logical Business Document. Given whether simple or complex variables are used,
XPath or XSLT could be used, for example. Note: This complexType was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:complexType>
<xsd:sequence>
<xsd:annotation>
<xsd:documentation>Exactly one ConditionExpression is used to provide values. If
multiple ConditionExpressions are listed, each expressionLanguage value is
different from others in the sequence and distinct.</xsd:documentation>
</xsd:annotation>
<xsd:element ref="ConditionExpression" maxOccurs="unbounded"/>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="businessTransactionActivityRef" type="xsd:IDREF" use="optional">
<xsd:annotation>
<xsd:documentation>The nameID reference of the Business Transaction Activity
associated with the semantic variable. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="businessDocumentRef" type="xsd:IDREF" use="optional">
<xsd:annotation>
<xsd:documentation>The nameID reference of the logical business document
associated with the semantic variable. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:element>
<xsd:element name="OperationMapping" type="OperationMappingType">
<xsd:annotation>
<xsd:documentation>An abstract element that allows mapping a BTA and its
BusinessDocuments to Interface/Operation messages. Specifies input, output,
fault, interface, operation map to role, BTA and document envelope or Business Signal
references. Note: This element was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="OperationMappingType">
<xsd:annotation>
<xsd:documentation>The type related to the abstract element mapping Operations to
Business Actions, either business messages or signals. Note: This complexType was
added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:sequence>
<xsd:element name="MessageMap" maxOccurs="unbounded">
<xsd:complexType>
<xsd:attributeGroup ref="map"/>
</xsd:complexType>
</xsd:element>
<xsd:element name="SignalMap" minOccurs="0" maxOccurs="8">
<xsd:complexType>
<xsd:attributeGroup ref="map"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
<xsd:attributeGroup ref="name"/>
<xsd:attribute name="roleRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>Maps to a Role element contained in
collaboration.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="businessTransactionActivityRef" type="xsd:IDREF" use="required"/>
</xsd:complexType>
<xsd:simpleType name="TimeToPerformType">
<xsd:annotation>
<xsd:documentation>The simpleType related to the definition of Time To Perform during
the process lifecycle. Allows for late binding. Note: This simpleType was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="design"/>
<xsd:enumeration value="configuration"/>
<xsd:enumeration value="runtime"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="BusinessDocumentValueList">
<xsd:annotation>
<xsd:documentation>The simpleType related to the (future) enumerated list for the
Business Document list associated with the Status Visibility element. This
simpleType is used in exposing visibility to documents from more deeply nested BTA.
Thoses values are to be available as the expression language listed. Note: This
simpleType was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:list itemType="xsd:NMTOKEN"/>
</xsd:simpleType>
<xsd:simpleType name="ConditionGuardValueList">
<xsd:annotation>
<xsd:documentation>The simpleType related to the content model for Status Visibility.
Note: This simpleType was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:list itemType="ConditionGuardValue"/>
</xsd:simpleType>
<xsd:simpleType name="ConditionGuardValue">
<xsd:annotation>
<xsd:documentation>The simpleType related to the enumerated list for the guard values
associated with the FromLink in a Completion State. Each of the FromLinks in a
Completion State can be specified to transition as a result of the
ConditionGuardValues. This check is made every time a transition occurs from the
real states. Because the FromLinks generally are from a specific state, only when
that state has been reached is the check of conditionGuards from that state checked.
Business Success and Failure relate to the business documents received. While
conversely, any timeout is a business protocol failure, i.e. the state is not
aligned. Note: This simpleType was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ProtocolSuccess"/>
<xsd:enumeration value="AnyProtocolFailure"/>
<xsd:enumeration value="RequestReceiptFailure"/>
<xsd:enumeration value="RequestAcceptanceFailure"/>
<xsd:enumeration value="ResponseReceiptFailure"/>
<xsd:enumeration value="ResponseAcceptanceFailure"/>
<xsd:enumeration value="SignalTimeout"/>
<xsd:enumeration value="ResponseTimeout"/>
<xsd:enumeration value="BusinessSuccess"/>
<xsd:enumeration value="BusinessFailure"/>
<xsd:enumeration value="Success"/>
<xsd:enumeration value="Failure"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="DocumentSpecificationType">
<xsd:annotation>
<xsd:documentation>The simpleType related to the enumerated list of specification types
for the Specification element. Note: This simpleType was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="schema"/>
<xsd:enumeration value="dtd"/>
<xsd:enumeration value="wsdl"/>
<xsd:enumeration value="relaxng"/>
<xsd:enumeration value="schematron"/>
<xsd:enumeration value="other"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="StepType">
<xsd:annotation>
<xsd:documentation>The simpleType related to the enumerated list of operation types
supported by OperationMapping and OperationMappingType. Note: This simpleType was
added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="input"/>
<xsd:enumeration value="output"/>
<xsd:enumeration value="fault"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="ExpressionLanguageType">
<xsd:annotation>
<xsd:documentation>This simpleType relates to the types of Expression language. An
enumerated list is provided. Note: This simpleType was added in
v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="ConditionGuardValue"/>
<xsd:enumeration value="DocumentEnvelope"/>
<xsd:enumeration value="XPath1"/>
<xsd:enumeration value="XSLT1"/>
<xsd:enumeration value="CAM1"/>
<xsd:enumeration value="XPath2"/>
<xsd:enumeration value="XSLT2"/>
<xsd:enumeration value="XQuery1"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:attributeGroup name="documentSecurity">
<xsd:annotation>
<xsd:documentation>The attributeGroup related to document security, quality of service
attributes. These attributes relate to the BT patterns and the operational semantics
surrounding their use. </xsd:documentation>
</xsd:annotation>
<xsd:attribute name="isAuthenticated">
<xsd:annotation>
<xsd:documentation>The communications channel used to transport the Message provides
transient authentication. The specific method will be determined by the
communications protocol used. Persistent authentication means the Business
Document signer’s identity is verified at the receiving application level.
Authentication assists in verification of role identity of a participating
party.</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="none"/>
<xsd:enumeration value="transient"/>
<xsd:enumeration value="persistent"/>
<xsd:enumeration value="transient-and-persistent"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="isConfidential">
<xsd:annotation>
<xsd:documentation>Transient confidentiality is provided by a secure network
protocol, such as SSL as the document is transferred between two adjacent ebXML
Messaging Service or other transport messaging nodes. Persistent
confidentiality is intended to preserve the confidentiality of the message such
that only the intended party (application) can see it.</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="none"/>
<xsd:enumeration value="transient"/>
<xsd:enumeration value="persistent"/>
<xsd:enumeration value="transient-and-persistent"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="isTamperDetectable">
<xsd:annotation>
<xsd:documentation>Transient isTamperDetectable is the ability to detect if the
information has been tampered with during transfer between two adjacent Message Service Handler
nodes. Persistent isTamperDetectable is the ability to detect if the information
has been tampered with after it has been received by messaging node, between the
messaging node and the application. Tamper detection assists in verification of
content integrity between and within a participating party.</xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:NMTOKEN">
<xsd:enumeration value="none"/>
<xsd:enumeration value="transient"/>
<xsd:enumeration value="persistent"/>
<xsd:enumeration value="transient-and-persistent"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="map">
<xsd:annotation>
<xsd:documentation>The attributeGroup related to interface/operation types supported by
OperationMapping and OperationMappingType. The abstract map includes the interface,
operation, the step (see StepType) and the document reference. Note:
This attributeGroup was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="interfaceName" type="xsd:NMTOKEN" use="required">
<xsd:annotation>
<xsd:documentation>Interface is called portType in WSDL 1.1. The name of the
interface or portType mapped logically in Operation Mapping. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="operationName" type="xsd:NMTOKEN" use="required">
<xsd:annotation>
<xsd:documentation>The name of the operation mapped in the
OperationMapping. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="operationStep" type="StepType" use="required">
<xsd:annotation>
<xsd:documentation>The name of operation step from the Step Type enumeration list
for OperationMapping. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="documentEnvelopeRef" type="xsd:IDREF" use="required">
<xsd:annotation>
<xsd:documentation>The nameID reference of the Document Envelope related to the
OperationMapping. Note: This attribute was added in v2.0.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
<xsd:attributeGroup name="name">
<xsd:annotation>
<xsd:documentation>The attributeGroup related to the identification information for most
elements. For the name attribute, no white space restrictions are enforced. White
space is not controlled but left to implementation to trigger faults or exceptions.
Note: This group was enhanced to include not only name but
nameID in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="name" type="xsd:string" use="required">
<xsd:annotation>
<xsd:documentation>A designation that may be relevant to a business analyst but is
not intended for referencing.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="nameID" type="xsd:ID" use="required">
<xsd:annotation>
<xsd:documentation>Used for referencing, for example, for identification of elements
within an ebBP instance.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:attributeGroup>
<xsd:attributeGroup name="optname">
<xsd:annotation>
<xsd:documentation>The optname attributeGroup related to the identification information
for some elements. This allows name or nameID to be optionally used. No white space restrictions are
enforced. White space is not controlled but left to implementation to trigger faults
or exceptions. Note: This group was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="name" type="xsd:string"/>
<xsd:attribute name="nameID" type="xsd:ID"/>
<xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:attributeGroup>
<xsd:attributeGroup name="quality">
<xsd:annotation>
<xsd:documentation>The attributeGroup related to quality of service attributes. These
attributes relate to the BT patterns and the operational semantics surrounding their
use. Note: This attributeGroup was added in v2.0.</xsd:documentation>
</xsd:annotation>
<xsd:attribute name="isAuthorizationRequired" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>When a party uses isAuthorizationRequired on a Requesting
and/or a Responding activity accordingly, the result that [the activity]
will only be processed as valid if the party interpreting it successfully
matches the stated identity of the activity's [Role] to a list of allowed values
previously supplied by that party. Authorization typically relates to a signed
business document and the association to the role identity of the party expected
for that activity.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isIntelligibleCheckRequired" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>Allows partners to agree that a message is confirmed by a
Receipt Acknowledgement only if it is also legible. Legible means that it has
passed structure/schema validity check. The content of the receipt and the
legibility of a business message (if required) are reviewed prior to the
processing of the Business Document or the evaluation of Condition Expressions
in the business message's Business Documents or Document Envelope.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isNonRepudiationRequired" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>If non-repudiation of origin and content is required, then the
Business Activity stores the business document in its original form for the
duration mutually agreed to in an agreement. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="isNonRepudiationReceiptRequired" type="xsd:boolean">
<xsd:annotation>
<xsd:documentation>Both parties agree to mutually verify receipt of a Requesting
Business Document and that the receipt is non-repudiable.
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="timeToAcknowledgeReceipt" type="xsd:duration">
<xsd:annotation>
<xsd:documentation>The time a Responding or Requesting role has to acknowledge
receipt of a Business Document. </xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="timeToAcknowledgeAcceptance" type="xsd:duration">
<xsd:annotation>
<xsd:documentation>The time a Requesting and Responding role has to
non-substantively acknowledge business acceptance of a Business
Document.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="retryCount" type="xsd:int">
<xsd:annotation>
<xsd:documentation>The business retry for a RequestingBusinessActivity identifies
the number of retries allowed in addition to the initial request while the Time
To Perform has not been exceeded.</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>
</xsd:schema>
\ No newline at end of file
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xenc-schema.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xenc-schema.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..91686de7db4800811688f39fb4c4e2be8370ee5c
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xenc-schema.xsd
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<schema targetNamespace="http://www.w3.org/2001/04/xmlenc#" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:xenc="http://www.w3.org/2001/04/xmlenc#" xmlns="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" version="1.0">
+ <import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd" />
+ <complexType name="EncryptedType" abstract="true">
+ <sequence>
+ <element name="EncryptionMethod" type="xenc:EncryptionMethodType" minOccurs="0" />
+ <element ref="ds:KeyInfo" minOccurs="0" />
+ <element ref="xenc:CipherData" />
+ <element ref="xenc:EncryptionProperties" minOccurs="0" />
+ </sequence>
+ <attribute name="Id" type="ID" use="optional" />
+ <attribute name="Type" type="anyURI" use="optional" />
+ <attribute name="MimeType" type="string" use="optional" />
+ <attribute name="Encoding" type="anyURI" use="optional" />
+ </complexType>
+ <complexType name="EncryptionMethodType" mixed="true">
+ <sequence>
+ <element name="KeySize" type="xenc:KeySizeType" minOccurs="0" />
+ <element name="OAEPparams" type="base64Binary" minOccurs="0" />
+ <any namespace="##other" minOccurs="0" maxOccurs="unbounded" /> <!-- <element ref='ds:DigestMethod' minOccurs='0'/> -->
+ </sequence>
+ <attribute name="Algorithm" type="anyURI" use="required" />
+ </complexType>
+ <simpleType name="KeySizeType">
+ <restriction base="integer" />
+ </simpleType>
+ <element name="CipherData" type="xenc:CipherDataType" />
+ <complexType name="CipherDataType">
+ <choice>
+ <element name="CipherValue" type="base64Binary" />
+ <element ref="xenc:CipherReference" />
+ </choice>
+ </complexType>
+ <element name="CipherReference" type="xenc:CipherReferenceType" />
+ <complexType name="CipherReferenceType">
+ <choice>
+ <element name="Transforms" type="xenc:TransformsType" minOccurs="0" />
+ </choice>
+ <attribute name="URI" type="anyURI" use="required" />
+ </complexType>
+ <complexType name="TransformsType">
+ <sequence>
+ <element ref="ds:Transform" maxOccurs="unbounded" />
+ </sequence>
+ </complexType>
+ <element name="EncryptedData" type="xenc:EncryptedDataType" />
+ <complexType name="EncryptedDataType">
+ <complexContent>
+ <extension base="xenc:EncryptedType" />
+ </complexContent>
+ </complexType> <!-- Children of ds:KeyInfo -->
+ <element name="EncryptedKey" type="xenc:EncryptedKeyType" />
+ <complexType name="EncryptedKeyType">
+ <complexContent>
+ <extension base="xenc:EncryptedType">
+ <sequence>
+ <element ref="xenc:ReferenceList" minOccurs="0" />
+ <element name="CarriedKeyName" type="string" minOccurs="0" />
+ </sequence>
+ <attribute name="Recipient" type="string" use="optional" />
+ </extension>
+ </complexContent>
+ </complexType>
+ <element name="AgreementMethod" type="xenc:AgreementMethodType" />
+ <complexType name="AgreementMethodType" mixed="true">
+ <sequence>
+ <element name="KA-Nonce" type="base64Binary" minOccurs="0" />
+ <element ref="ds:DigestMethod" minOccurs="0" />
+ <element name="OriginatorKeyInfo" type="ds:KeyInfoType" minOccurs="0" />
+ <element name="RecipientKeyInfo" type="ds:KeyInfoType" minOccurs="0" />
+ <!-- <any namespace="##other" minOccurs="0" maxOccurs="unbounded" /> -->
+ </sequence>
+ <attribute name="Algorithm" type="anyURI" use="required" />
+ </complexType> <!-- End Children of ds:KeyInfo -->
+ <element name="ReferenceList">
+ <complexType>
+ <choice minOccurs="0" maxOccurs="unbounded">
+ <element name="DataReference" type="xenc:ReferenceType" />
+ <element name="KeyReference" type="xenc:ReferenceType" />
+ </choice>
+ </complexType>
+ </element>
+ <complexType name="ReferenceType">
+ <sequence>
+ <any namespace="##other" minOccurs="0" maxOccurs="unbounded" />
+ </sequence>
+ <attribute name="URI" type="anyURI" use="required" />
+ </complexType>
+ <element name="EncryptionProperties" type="xenc:EncryptionPropertiesType" />
+ <complexType name="EncryptionPropertiesType">
+ <sequence>
+ <element ref="xenc:EncryptionProperty" maxOccurs="unbounded" />
+ </sequence>
+ <attribute name="Id" type="ID" use="optional" />
+ </complexType>
+ <element name="EncryptionProperty" type="xenc:EncryptionPropertyType" />
+ <complexType name="EncryptionPropertyType" mixed="true">
+ <choice maxOccurs="unbounded">
+ <any namespace="##other" processContents="lax" />
+ </choice>
+ <attribute name="Target" type="anyURI" use="optional" />
+ <attribute name="Id" type="ID" use="optional" />
+ <anyAttribute namespace="http://www.w3.org/XML/1998/namespace" />
+ </complexType>
+</schema>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xkms.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xkms.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..29ea6f9e1a960a257876e6f0c0b73f25d170c171
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xkms.xsd
@@ -0,0 +1,439 @@
+<?xml version="1.0"?>
+<!DOCTYPE schema [
+ <!-- The URI for the XKMS namespace, and also the base URI used for
+ URI's defined by the specification. -->
+ <!ENTITY xkms 'http://www.w3.org/2002/03/xkms#'>
+]>
+<schema xmlns:xkms="http://www.w3.org/2002/03/xkms#"
+ xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+ xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"
+ xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/2002/03/xkms#" elementFormDefault="qualified" attributeFormDefault="unqualified">
+<import namespace="http://www.w3.org/2000/09/xmldsig#" schemaLocation="xmldsig-core-schema.xsd"></import>
+<import namespace="http://www.w3.org/2001/04/xmlenc#" schemaLocation="xenc-schema.xsd"></import>
+<annotation>
+<documentation xml:lang="en">
+ XML Schema for XKMS 2.0 Recommendation
+</documentation></annotation>
+<!-- /Namespace -->
+<!-- MessageAbstractType -->
+<complexType name="MessageAbstractType" abstract="true">
+<sequence>
+<element ref="ds:Signature" minOccurs="0"></element>
+<element ref="xkms:MessageExtension" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:OpaqueClientData" minOccurs="0"></element></sequence>
+<attribute name="Id" type="ID" use="required"></attribute>
+<attribute name="Service" type="anyURI" use="required"></attribute>
+<attribute name="Nonce" type="base64Binary" use="optional"></attribute></complexType>
+<!-- /MessageAbstractType -->
+<!-- MessageExtension -->
+<element name="MessageExtension" type="xkms:MessageExtensionAbstractType" abstract="true"></element>
+<complexType name="MessageExtensionAbstractType" abstract="true"></complexType>
+<!-- /MessageExtension -->
+<!-- OpaqueClientData -->
+<element name="OpaqueClientData" type="xkms:OpaqueClientDataType"></element>
+<complexType name="OpaqueClientDataType">
+<sequence maxOccurs="unbounded">
+<element ref="xkms:OpaqueData" minOccurs="0"></element></sequence></complexType>
+<element name="OpaqueData" type="base64Binary"></element>
+<!-- /OpaqueClientData -->
+<!-- RequestAbstractType -->
+<complexType name="RequestAbstractType" abstract="true">
+<complexContent>
+<extension base="xkms:MessageAbstractType">
+<sequence>
+<element ref="xkms:ResponseMechanism" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:RespondWith" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:PendingNotification" minOccurs="0"></element></sequence>
+<attribute name="OriginalRequestId" type="NCName" use="optional"></attribute>
+<attribute name="ResponseLimit" type="integer" use="optional"></attribute></extension></complexContent></complexType>
+<!-- /RequestAbstractType -->
+<!-- ResponseMechanism -->
+<simpleType name="ResponseMechanismEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#Pending"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Represent"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#RequestSignatureValue"></enumeration></restriction></simpleType>
+<simpleType name="ResponseMechanismOpenEnum">
+<union memberTypes="xkms:ResponseMechanismEnum anyURI"></union></simpleType>
+<element name="ResponseMechanism" type="xkms:ResponseMechanismOpenEnum"></element>
+<!-- /ResponseMechanism -->
+<!-- RespondWith -->
+<simpleType name="RespondWithEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#KeyName"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#KeyValue"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#X509Cert"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#X509Chain"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#X509CRL"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#RetrievalMethod"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#PGP"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#PGPWeb"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#SPKI"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#PrivateKey"></enumeration></restriction></simpleType>
+<simpleType name="RespondWithOpenEnum">
+<union memberTypes="xkms:RespondWithEnum anyURI"></union></simpleType>
+<element name="RespondWith" type="xkms:RespondWithOpenEnum"></element>
+<!-- /RespondWith -->
+<!-- PendingNotification -->
+<element name="PendingNotification" type="xkms:PendingNotificationType"></element>
+<complexType name="PendingNotificationType">
+<attribute name="Mechanism" type="anyURI" use="required"></attribute>
+<attribute name="Identifier" type="anyURI" use="required"></attribute></complexType>
+<!-- /PendingNotification -->
+<!-- PendingRequest -->
+<element name="PendingRequest" type="xkms:PendingRequestType"></element>
+<complexType name="PendingRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<attribute name="ResponseId" type="NCName" use="required"></attribute></extension></complexContent></complexType>
+<!-- /PendingRequest -->
+<!-- ResultType -->
+<element name="Result" type="xkms:ResultType"></element>
+<simpleType name="ResultMajorEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#Success"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#VersionMismatch"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Sender"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Receiver"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Represent"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Pending"></enumeration></restriction></simpleType>
+<simpleType name="ResultMajorOpenEnum">
+<union memberTypes="xkms:ResultMajorEnum anyURI"></union></simpleType>
+<simpleType name="ResultMinorEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#NoMatch"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#TooManyResponses"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Incomplete"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Failure"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Refused"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#NoAuthentication"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#MessageNotSupported"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#UnknownResponseId"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#RepresentRequired"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#NotSynchronous"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#OptionalElementNotSupported"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#ProofOfPossessionRequired"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#TimeInstantNotSupported"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#TimeInstantOutOfRange"></enumeration>
+
+</restriction></simpleType>
+<simpleType name="ResultMinorOpenEnum">
+<union memberTypes="xkms:ResultMinorEnum anyURI"></union></simpleType>
+<complexType name="ResultType">
+<complexContent>
+<extension base="xkms:MessageAbstractType">
+<sequence>
+<element ref="xkms:RequestSignatureValue" minOccurs="0"></element></sequence>
+<attribute name="ResultMajor" type="xkms:ResultMajorOpenEnum" use="required"></attribute>
+<attribute name="ResultMinor" type="xkms:ResultMinorOpenEnum" use="optional"></attribute>
+<attribute name="RequestId" type="NCName" use="optional"></attribute></extension></complexContent></complexType>
+<!-- /ResultType -->
+<!-- RequestSignatureValue -->
+<element name="RequestSignatureValue" type="ds:SignatureValueType"></element>
+<!-- /RequestSignatureValue -->
+<!-- CompoundRequest -->
+<element name="CompoundRequest" type="xkms:CompoundRequestType"></element>
+<complexType name="CompoundRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<choice maxOccurs="unbounded">
+<element ref="xkms:LocateRequest"></element>
+<element ref="xkms:ValidateRequest"></element>
+<element ref="xkms:RegisterRequest"></element>
+<element ref="xkms:ReissueRequest"></element>
+<element ref="xkms:RecoverRequest"></element>
+<element ref="xkms:RevokeRequest"></element></choice></extension></complexContent></complexType>
+<!-- /CompoundRequest -->
+<!-- CompoundResult -->
+<element name="CompoundResult" type="xkms:CompoundResultType"></element>
+<complexType name="CompoundResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<choice minOccurs="0" maxOccurs="unbounded">
+<element ref="xkms:LocateResult"></element>
+<element ref="xkms:ValidateResult"></element>
+<element ref="xkms:RegisterResult"></element>
+<element ref="xkms:ReissueResult"></element>
+<element ref="xkms:RecoverResult"></element>
+<element ref="xkms:RevokeResult"></element></choice></extension></complexContent></complexType>
+<!-- /CompoundResult -->
+<!-- StatusRequest -->
+<element name="StatusRequest" type="xkms:StatusRequestType"></element>
+<complexType name="StatusRequestType">
+<complexContent>
+<extension base="xkms:PendingRequestType"></extension></complexContent></complexType>
+<!-- /StatusRequest -->
+<!-- StatusResult -->
+<element name="StatusResult" type="xkms:StatusResultType"></element>
+<complexType name="StatusResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<attribute name="Success" type="integer" use="optional"></attribute>
+<attribute name="Failure" type="integer" use="optional"></attribute>
+<attribute name="Pending" type="integer" use="optional"></attribute></extension></complexContent></complexType>
+<!-- /StatusResult -->
+<!-- KeyBindingAbstractType-->
+<complexType name="KeyBindingAbstractType" abstract="true">
+<sequence>
+<element ref="ds:KeyInfo" minOccurs="0"></element>
+<element ref="xkms:KeyUsage" minOccurs="0" maxOccurs="3"></element>
+<element ref="xkms:UseKeyWith" minOccurs="0" maxOccurs="unbounded"></element></sequence>
+<attribute name="Id" type="ID" use="optional"></attribute></complexType>
+<!-- /KeyBindingAbstractType-->
+<!-- UnverifiedKeyBinding -->
+<element name="UnverifiedKeyBinding" type="xkms:UnverifiedKeyBindingType"></element>
+<complexType name="UnverifiedKeyBindingType">
+<complexContent>
+<extension base="xkms:KeyBindingAbstractType">
+<sequence>
+<element ref="xkms:ValidityInterval" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<!-- /UnverifiedKeyBinding -->
+<!-- KeyBinding -->
+<element name="KeyBinding" type="xkms:KeyBindingType"></element>
+<complexType name="KeyBindingType">
+<complexContent>
+<extension base="xkms:UnverifiedKeyBindingType">
+<sequence>
+<element ref="xkms:Status"></element></sequence></extension></complexContent></complexType>
+<!-- /KeyBinding -->
+<!-- KeyUsage -->
+<simpleType name="KeyUsageEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#Encryption"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Signature"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Exchange"></enumeration></restriction></simpleType>
+<element name="KeyUsage" type="xkms:KeyUsageEnum"></element>
+<!-- /KeyUsage -->
+<!-- UseKeyWith -->
+<element name="UseKeyWith" type="xkms:UseKeyWithType"></element>
+<complexType name="UseKeyWithType">
+<attribute name="Application" type="anyURI" use="required"></attribute>
+<attribute name="Identifier" type="string" use="required"></attribute></complexType>
+<!-- /UseKeyWith -->
+<!-- Status -->
+<element name="Status" type="xkms:StatusType"></element>
+<complexType name="StatusType">
+<sequence>
+<element ref="xkms:ValidReason" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:IndeterminateReason" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:InvalidReason" minOccurs="0" maxOccurs="unbounded"></element></sequence>
+<attribute name="StatusValue" type="xkms:KeyBindingEnum" use="required"></attribute></complexType>
+<simpleType name="KeyBindingEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#Valid"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Invalid"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Indeterminate"></enumeration></restriction></simpleType>
+<!-- /Status -->
+<!-- Reason -->
+<simpleType name="ReasonEnum">
+<restriction base="anyURI">
+<enumeration value="http://www.w3.org/2002/03/xkms#IssuerTrust"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#RevocationStatus"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#ValidityInterval"></enumeration>
+<enumeration value="http://www.w3.org/2002/03/xkms#Signature"></enumeration></restriction></simpleType>
+<simpleType name="ReasonOpenEnum">
+<union memberTypes="xkms:ReasonEnum anyURI"></union></simpleType>
+<element name="ValidReason" type="xkms:ReasonOpenEnum"></element>
+<element name="InvalidReason" type="xkms:ReasonOpenEnum"></element>
+<element name="IndeterminateReason" type="xkms:ReasonOpenEnum"></element>
+<!-- /Reason -->
+<!-- ValidityInterval -->
+<element name="ValidityInterval" type="xkms:ValidityIntervalType"></element>
+<complexType name="ValidityIntervalType">
+<attribute name="NotBefore" type="dateTime" use="optional"></attribute>
+<attribute name="NotOnOrAfter" type="dateTime" use="optional"></attribute></complexType>
+<!-- /ValidityInterval -->
+<!-- QueryKeyBinding -->
+<element name="QueryKeyBinding" type="xkms:QueryKeyBindingType"></element>
+<complexType name="QueryKeyBindingType">
+<complexContent>
+<extension base="xkms:KeyBindingAbstractType">
+<sequence>
+<element ref="xkms:TimeInstant" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<!-- /QueryKeyBinding -->
+<!-- TimeInstant -->
+<element name="TimeInstant" type="xkms:TimeInstantType"></element>
+<complexType name="TimeInstantType">
+<attribute name="Time" type="dateTime" use="required"></attribute></complexType>
+<!-- /TimeInstant -->
+<!-- PrototypeKeyBinding -->
+<element name="PrototypeKeyBinding" type="xkms:PrototypeKeyBindingType"></element>
+<complexType name="PrototypeKeyBindingType">
+<complexContent>
+<extension base="xkms:KeyBindingAbstractType">
+<sequence>
+<element ref="xkms:ValidityInterval" minOccurs="0"></element>
+<element ref="xkms:RevocationCodeIdentifier" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<!-- /PrototypeKeyBinding -->
+<!-- RevocationCodeIdentifier -->
+<element name="RevocationCodeIdentifier" type="xkms:RevocationCodeIdentifierType"></element>
+<simpleType name="RevocationCodeIdentifierType">
+<restriction base="base64Binary"></restriction></simpleType>
+<!-- /RevocationCodeIdentifier -->
+<!-- LocateRequest -->
+<element name="LocateRequest" type="xkms:LocateRequestType"></element>
+<complexType name="LocateRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<sequence>
+<element ref="xkms:QueryKeyBinding"></element></sequence></extension></complexContent></complexType>
+<!-- /LocateRequest -->
+<!-- LocateResult -->
+<element name="LocateResult" type="xkms:LocateResultType"></element>
+<complexType name="LocateResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<sequence>
+<element ref="xkms:UnverifiedKeyBinding" minOccurs="0" maxOccurs="unbounded"></element></sequence></extension></complexContent></complexType>
+<!-- /LocateResult -->
+<!-- ValidateRequest -->
+<element name="ValidateRequest" type="xkms:ValidateRequestType"></element>
+<complexType name="ValidateRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<sequence>
+<element ref="xkms:QueryKeyBinding"></element></sequence></extension></complexContent></complexType>
+<!-- /ValidateRequest -->
+<!-- ValidateResult -->
+<element name="ValidateResult" type="xkms:ValidateResultType"></element>
+<complexType name="ValidateResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<sequence>
+<element ref="xkms:KeyBinding" minOccurs="0" maxOccurs="unbounded"></element></sequence></extension></complexContent></complexType>
+<!-- /ValidateResult -->
+<!-- Authentication -->
+<element name="Authentication" type="xkms:AuthenticationType"></element>
+<complexType name="AuthenticationType">
+<sequence>
+<element ref="xkms:KeyBindingAuthentication" minOccurs="0"></element>
+<element ref="xkms:NotBoundAuthentication" minOccurs="0"></element></sequence></complexType>
+<!-- /Authentication -->
+<!-- KeyBindingAuthentication -->
+<element name="KeyBindingAuthentication" type="xkms:KeyBindingAuthenticationType"></element>
+<complexType name="KeyBindingAuthenticationType">
+<sequence>
+<element ref="ds:Signature"></element></sequence></complexType>
+<!-- /KeyBindingAuthentication -->
+<!-- NotBoundAuthentication -->
+<element name="NotBoundAuthentication" type="xkms:NotBoundAuthenticationType"></element>
+<complexType name="NotBoundAuthenticationType">
+<attribute name="Protocol" type="anyURI" use="required"></attribute>
+<attribute name="Value" type="base64Binary" use="required"></attribute></complexType>
+<!-- /NotBoundAuthentication -->
+<!-- ProofOfPossession -->
+<element name="ProofOfPossession" type="xkms:ProofOfPossessionType"></element>
+<complexType name="ProofOfPossessionType">
+<sequence>
+<element ref="ds:Signature"></element></sequence></complexType>
+<!-- /ProofOfPossession -->
+<!-- PrivateKey -->
+<element name="PrivateKey" type="xkms:PrivateKeyType"></element>
+<complexType name="PrivateKeyType">
+<sequence>
+<element ref="xenc:EncryptedData"></element></sequence></complexType>
+<!-- /PrivateKey -->
+<!-- RegisterRequest -->
+<element name="RegisterRequest" type="xkms:RegisterRequestType"></element>
+<complexType name="RegisterRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<sequence>
+<element ref="xkms:PrototypeKeyBinding"></element>
+<element ref="xkms:Authentication"></element>
+<element ref="xkms:ProofOfPossession" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<!-- /RegisterRequest -->
+<!-- RegisterResult -->
+<element name="RegisterResult" type="xkms:RegisterResultType"></element>
+<complexType name="RegisterResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<sequence>
+<element ref="xkms:KeyBinding" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:PrivateKey" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<!-- /RegisterResult -->
+<!-- ReissueRequest -->
+<element name="ReissueRequest" type="xkms:ReissueRequestType"></element>
+<complexType name="ReissueRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<sequence>
+<element ref="xkms:ReissueKeyBinding"></element>
+<element ref="xkms:Authentication"></element>
+<element ref="xkms:ProofOfPossession" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<element name="ReissueKeyBinding" type="xkms:KeyBindingType"></element>
+<!-- /ReissueRequest -->
+<!-- ReissueResult -->
+<element name="ReissueResult" type="xkms:ReissueResultType"></element>
+<complexType name="ReissueResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<sequence>
+<element ref="xkms:KeyBinding" minOccurs="0" maxOccurs="unbounded"></element></sequence></extension></complexContent></complexType>
+<!-- /ReissueResult -->
+<!-- RevokeRequest -->
+<element name="RevokeRequest" type="xkms:RevokeRequestType"></element>
+<complexType name="RevokeRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<sequence>
+<element ref="xkms:RevokeKeyBinding"></element>
+<choice>
+<element ref="xkms:Authentication"></element>
+<element ref="xkms:RevocationCode"></element></choice></sequence></extension></complexContent></complexType>
+<element name="RevokeKeyBinding" type="xkms:KeyBindingType"></element>
+<!-- /RevokeRequest -->
+<!-- RevocationCode -->
+<element name="RevocationCode" type="xkms:RevocationCodeType"></element>
+<simpleType name="RevocationCodeType">
+<restriction base="base64Binary"></restriction></simpleType>
+<!-- /RevocationCode -->
+<!-- RevokeResult -->
+<element name="RevokeResult" type="xkms:RevokeResultType"></element>
+<complexType name="RevokeResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<sequence>
+<element ref="xkms:KeyBinding" minOccurs="0" maxOccurs="unbounded"></element></sequence></extension></complexContent></complexType>
+<!-- /RevokeResult -->
+<!-- RecoverRequest -->
+<element name="RecoverRequest" type="xkms:RecoverRequestType"></element>
+<complexType name="RecoverRequestType">
+<complexContent>
+<extension base="xkms:RequestAbstractType">
+<sequence>
+<element ref="xkms:RecoverKeyBinding"></element>
+<element ref="xkms:Authentication"></element></sequence></extension></complexContent></complexType>
+<element name="RecoverKeyBinding" type="xkms:KeyBindingType"></element>
+<!-- /RecoverRequest -->
+<!-- RecoverResult -->
+<element name="RecoverResult" type="xkms:RecoverResultType"></element>
+<complexType name="RecoverResultType">
+<complexContent>
+<extension base="xkms:ResultType">
+<sequence>
+<element ref="xkms:KeyBinding" minOccurs="0" maxOccurs="unbounded"></element>
+<element ref="xkms:PrivateKey" minOccurs="0"></element></sequence></extension></complexContent></complexType>
+<!-- /RecoverResult -->
+<!-- RSAKeyPair -->
+<element name="RSAKeyPair" type="xkms:RSAKeyPairType"></element>
+<complexType name="RSAKeyPairType">
+<sequence>
+<element ref="xkms:Modulus"></element>
+<element ref="xkms:Exponent"></element>
+<element ref="xkms:P"></element>
+<element ref="xkms:Q"></element>
+<element ref="xkms:DP"></element>
+<element ref="xkms:DQ"></element>
+<element ref="xkms:InverseQ"></element>
+<element ref="xkms:D"></element></sequence></complexType>
+<element name="Modulus" type="ds:CryptoBinary"></element>
+<element name="Exponent" type="ds:CryptoBinary"></element>
+<element name="P" type="ds:CryptoBinary"></element>
+<element name="Q" type="ds:CryptoBinary"></element>
+<element name="DP" type="ds:CryptoBinary"></element>
+<element name="DQ" type="ds:CryptoBinary"></element>
+<element name="InverseQ" type="ds:CryptoBinary"></element>
+<element name="D" type="ds:CryptoBinary"></element>
+<!-- /RSAKeyPair -->
+<!-- End Schema --></schema>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xml.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xml.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..bd291f3d4be818edcb1498697ffd03f0226a9cf8
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xml.xsd
@@ -0,0 +1,286 @@
+<?xml version='1.0'?>
+<?xml-stylesheet href="../../2008/09/xsd.xsl" type="text/xsl"?>
+<xs:schema targetNamespace="http://www.w3.org/XML/1998/namespace"
+ xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns ="http://www.w3.org/1999/xhtml"
+ xml:lang="en">
+
+ <xs:annotation>
+ <xs:documentation>
+ <div>
+ <h1>About the XML namespace</h1>
+
+ <div class="bodytext">
+ <p>
+ This schema document describes the XML namespace, in a form
+ suitable for import by other schema documents.
+ </p>
+ <p>
+ See <a href="http://www.w3.org/XML/1998/namespace.html">
+ http://www.w3.org/XML/1998/namespace.html</a> and
+ <a href="http://www.w3.org/TR/REC-xml">
+ http://www.w3.org/TR/REC-xml</a> for information
+ about this namespace.
+ </p>
+ <p>
+ Note that local names in this namespace are intended to be
+ defined only by the World Wide Web Consortium or its subgroups.
+ The names currently defined in this namespace are listed below.
+ They should not be used with conflicting semantics by any Working
+ Group, specification, or document instance.
+ </p>
+ <p>
+ See further below in this document for more information about <a
+ href="#usage">how to refer to this schema document from your own
+ XSD schema documents</a> and about <a href="#nsversioning">the
+ namespace-versioning policy governing this schema document</a>.
+ </p>
+ </div>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+
+ <xs:attribute name="lang">
+ <xs:annotation>
+ <xs:documentation>
+ <div>
+
+ <h3>lang (as an attribute name)</h3>
+ <p>
+ denotes an attribute whose value
+ is a language code for the natural language of the content of
+ any element; its value is inherited. This name is reserved
+ by virtue of its definition in the XML specification.</p>
+
+ </div>
+ <div>
+ <h4>Notes</h4>
+ <p>
+ Attempting to install the relevant ISO 2- and 3-letter
+ codes as the enumerated possible values is probably never
+ going to be a realistic possibility.
+ </p>
+ <p>
+ See BCP 47 at <a href="http://www.rfc-editor.org/rfc/bcp/bcp47.txt">
+ http://www.rfc-editor.org/rfc/bcp/bcp47.txt</a>
+ and the IANA language subtag registry at
+ <a href="http://www.iana.org/assignments/language-subtag-registry">
+ http://www.iana.org/assignments/language-subtag-registry</a>
+ for further information.
+ </p>
+ <p>
+ The union allows for the 'un-declaration' of xml:lang with
+ the empty string.
+ </p>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:union memberTypes="xs:language">
+ <xs:simpleType>
+ <xs:restriction base="xs:string">
+ <xs:enumeration value=""/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:union>
+ </xs:simpleType>
+ </xs:attribute>
+
+ <xs:attribute name="space">
+ <xs:annotation>
+ <xs:documentation>
+ <div>
+
+ <h3>space (as an attribute name)</h3>
+ <p>
+ denotes an attribute whose
+ value is a keyword indicating what whitespace processing
+ discipline is intended for the content of the element; its
+ value is inherited. This name is reserved by virtue of its
+ definition in the XML specification.</p>
+
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:NCName">
+ <xs:enumeration value="default"/>
+ <xs:enumeration value="preserve"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:attribute>
+
+ <xs:attribute name="base" type="xs:anyURI"> <xs:annotation>
+ <xs:documentation>
+ <div>
+
+ <h3>base (as an attribute name)</h3>
+ <p>
+ denotes an attribute whose value
+ provides a URI to be used as the base for interpreting any
+ relative URIs in the scope of the element on which it
+ appears; its value is inherited. This name is reserved
+ by virtue of its definition in the XML Base specification.</p>
+
+ <p>
+ See <a
+ href="http://www.w3.org/TR/xmlbase/">http://www.w3.org/TR/xmlbase/</a>
+ for information about this attribute.
+ </p>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+
+ <xs:attribute name="id" type="xs:ID">
+ <xs:annotation>
+ <xs:documentation>
+ <div>
+
+ <h3>id (as an attribute name)</h3>
+ <p>
+ denotes an attribute whose value
+ should be interpreted as if declared to be of type ID.
+ This name is reserved by virtue of its definition in the
+ xml:id specification.</p>
+
+ <p>
+ See <a
+ href="http://www.w3.org/TR/xml-id/">http://www.w3.org/TR/xml-id/</a>
+ for information about this attribute.
+ </p>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+
+ <xs:attributeGroup name="specialAttrs">
+ <xs:attribute ref="xml:base"/>
+ <xs:attribute ref="xml:lang"/>
+ <xs:attribute ref="xml:space"/>
+ <xs:attribute ref="xml:id"/>
+ </xs:attributeGroup>
+
+ <xs:annotation>
+ <xs:documentation>
+ <div>
+
+ <h3>Father (in any context at all)</h3>
+
+ <div class="bodytext">
+ <p>
+ denotes Jon Bosak, the chair of
+ the original XML Working Group. This name is reserved by
+ the following decision of the W3C XML Plenary and
+ XML Coordination groups:
+ </p>
+ <blockquote>
+ <p>
+ In appreciation for his vision, leadership and
+ dedication the W3C XML Plenary on this 10th day of
+ February, 2000, reserves for Jon Bosak in perpetuity
+ the XML name "xml:Father".
+ </p>
+ </blockquote>
+ </div>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+ <xs:documentation>
+ <div xml:id="usage" id="usage">
+ <h2><a name="usage">About this schema document</a></h2>
+
+ <div class="bodytext">
+ <p>
+ This schema defines attributes and an attribute group suitable
+ for use by schemas wishing to allow <code>xml:base</code>,
+ <code>xml:lang</code>, <code>xml:space</code> or
+ <code>xml:id</code> attributes on elements they define.
+ </p>
+ <p>
+ To enable this, such a schema must import this schema for
+ the XML namespace, e.g. as follows:
+ </p>
+ <pre>
+ <schema . . .>
+ . . .
+ <import namespace="http://www.w3.org/XML/1998/namespace"
+ schemaLocation="http://www.w3.org/2001/xml.xsd"/>
+ </pre>
+ <p>
+ or
+ </p>
+ <pre>
+ <import namespace="http://www.w3.org/XML/1998/namespace"
+ schemaLocation="http://www.w3.org/2009/01/xml.xsd"/>
+ </pre>
+ <p>
+ Subsequently, qualified reference to any of the attributes or the
+ group defined below will have the desired effect, e.g.
+ </p>
+ <pre>
+ <type . . .>
+ . . .
+ <attributeGroup ref="xml:specialAttrs"/>
+ </pre>
+ <p>
+ will define a type which will schema-validate an instance element
+ with any of those attributes.
+ </p>
+ </div>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+ <xs:documentation>
+ <div id="nsversioning" xml:id="nsversioning">
+ <h2><a name="nsversioning">Versioning policy for this schema document</a></h2>
+ <div class="bodytext">
+ <p>
+ In keeping with the XML Schema WG's standard versioning
+ policy, this schema document will persist at
+ <a href="http://www.w3.org/2009/01/xml.xsd">
+ http://www.w3.org/2009/01/xml.xsd</a>.
+ </p>
+ <p>
+ At the date of issue it can also be found at
+ <a href="http://www.w3.org/2001/xml.xsd">
+ http://www.w3.org/2001/xml.xsd</a>.
+ </p>
+ <p>
+ The schema document at that URI may however change in the future,
+ in order to remain compatible with the latest version of XML
+ Schema itself, or with the XML namespace itself. In other words,
+ if the XML Schema or XML namespaces change, the version of this
+ document at <a href="http://www.w3.org/2001/xml.xsd">
+ http://www.w3.org/2001/xml.xsd
+ </a>
+ will change accordingly; the version at
+ <a href="http://www.w3.org/2009/01/xml.xsd">
+ http://www.w3.org/2009/01/xml.xsd
+ </a>
+ will not change.
+ </p>
+ <p>
+ Previous dated (and unchanging) versions of this schema
+ document are at:
+ </p>
+ <ul>
+ <li><a href="http://www.w3.org/2009/01/xml.xsd">
+ http://www.w3.org/2009/01/xml.xsd</a></li>
+ <li><a href="http://www.w3.org/2007/08/xml.xsd">
+ http://www.w3.org/2007/08/xml.xsd</a></li>
+ <li><a href="http://www.w3.org/2004/10/xml.xsd">
+ http://www.w3.org/2004/10/xml.xsd</a></li>
+ <li><a href="http://www.w3.org/2001/03/xml.xsd">
+ http://www.w3.org/2001/03/xml.xsd</a></li>
+ </ul>
+ </div>
+ </div>
+ </xs:documentation>
+ </xs:annotation>
+
+</xs:schema>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig-core-schema.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig-core-schema.xsd
new file mode 100755
index 0000000000000000000000000000000000000000..b13e83af3dd191b4ff28db21790aace48507a358
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig-core-schema.xsd
@@ -0,0 +1,340 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Service Metadata Publishing (SMP) Version 2.0
+ Committee Specification Draft 01 / Public Review Draft 01
+ 18 July 2018
+ Copyright (c) OASIS Open 2018. All Rights Reserved.
+ Source: http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/csprd01/xsd/common/
+ Latest version of narrative specification: http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/bdx-smp-v2.0.html
+ TC IPR Statement: https://www.oasis-open.org/committees/bdxr/ipr.php
+-->
+<!--
+ Library: OASIS Service Metadata Publisher (SMP) 2.0 CSD01WD01
+ http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/csd01wd01/
+ Release Date: 12 April 2018
+ Module: SMPE-xmldsig-core-schema-2.0.xsd
+ Generated on: 2017-12-06 21:00(UTC)
+
+ This is a copy of
+ http://www.w3.org/TR/2008/REC-xmldsig-core-20080610/xmldsig-core-schema.xsd
+ modified only to remove the DOCTYPE declaration that has no impact on the
+ XDM model of the XML instance of this schema fragment:
+
+<!DOCTYPE schema
+ PUBLIC "-//W3C//DTD XMLSchema 200102//EN" "http://www.w3.org/2001/XMLSchema.dtd"
+ [
+ <!ATTLIST schema
+ xmlns:ds CDATA #FIXED "http://www.w3.org/2000/09/xmldsig#">
+ <!ENTITY dsig 'http://www.w3.org/2000/09/xmldsig#'>
+ <!ENTITY % p ''>
+ <!ENTITY % s ''>
+ ]>
+-->
+
+<!-- Schema for XML Signatures
+ http://www.w3.org/2000/09/xmldsig#
+ $Revision: 1.1 $ on $Date: 2002/02/08 20:32:26 $ by $Author: reagle $
+
+ Copyright 2001 The Internet Society and W3C (Massachusetts Institute
+ of Technology, Institut National de Recherche en Informatique et en
+ Automatique, Keio University). All Rights Reserved.
+ http://www.w3.org/Consortium/Legal/
+
+ This document is governed by the W3C Software License [1] as described
+ in the FAQ [2].
+
+ [1] http://www.w3.org/Consortium/Legal/copyright-software-19980720
+ [2] http://www.w3.org/Consortium/Legal/IPR-FAQ-20000620.html#DTD
+-->
+
+
+<schema xmlns="http://www.w3.org/2001/XMLSchema"
+ xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+ targetNamespace="http://www.w3.org/2000/09/xmldsig#"
+ version="0.1" elementFormDefault="qualified">
+
+<!-- Basic Types Defined for Signatures -->
+
+<simpleType name="CryptoBinary">
+ <restriction base="base64Binary">
+ </restriction>
+</simpleType>
+
+<!-- Start Signature -->
+
+<element name="Signature" type="ds:SignatureType"/>
+<complexType name="SignatureType">
+ <sequence>
+ <element ref="ds:SignedInfo"/>
+ <element ref="ds:SignatureValue"/>
+ <element ref="ds:KeyInfo" minOccurs="0"/>
+ <element ref="ds:Object" minOccurs="0" maxOccurs="unbounded"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+
+ <element name="SignatureValue" type="ds:SignatureValueType"/>
+ <complexType name="SignatureValueType">
+ <simpleContent>
+ <extension base="base64Binary">
+ <attribute name="Id" type="ID" use="optional"/>
+ </extension>
+ </simpleContent>
+ </complexType>
+
+<!-- Start SignedInfo -->
+
+<element name="SignedInfo" type="ds:SignedInfoType"/>
+<complexType name="SignedInfoType">
+ <sequence>
+ <element ref="ds:CanonicalizationMethod"/>
+ <element ref="ds:SignatureMethod"/>
+ <element ref="ds:Reference" maxOccurs="unbounded"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+
+ <element name="CanonicalizationMethod" type="ds:CanonicalizationMethodType"/>
+ <complexType name="CanonicalizationMethodType" mixed="true">
+ <sequence>
+ <any namespace="##any" minOccurs="0" maxOccurs="unbounded"/>
+ <!-- (0,unbounded) elements from (1,1) namespace -->
+ </sequence>
+ <attribute name="Algorithm" type="anyURI" use="required"/>
+ </complexType>
+
+ <element name="SignatureMethod" type="ds:SignatureMethodType"/>
+ <complexType name="SignatureMethodType" mixed="true">
+ <sequence>
+ <element name="HMACOutputLength" minOccurs="0" type="ds:HMACOutputLengthType"/>
+ <any namespace="##other" minOccurs="0" maxOccurs="unbounded"/>
+ <!-- (0,unbounded) elements from (1,1) external namespace -->
+ </sequence>
+ <attribute name="Algorithm" type="anyURI" use="required"/>
+ </complexType>
+
+<!-- Start Reference -->
+
+<element name="Reference" type="ds:ReferenceType"/>
+<complexType name="ReferenceType">
+ <sequence>
+ <element ref="ds:Transforms" minOccurs="0"/>
+ <element ref="ds:DigestMethod"/>
+ <element ref="ds:DigestValue"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+ <attribute name="URI" type="anyURI" use="optional"/>
+ <attribute name="Type" type="anyURI" use="optional"/>
+</complexType>
+
+ <element name="Transforms" type="ds:TransformsType"/>
+ <complexType name="TransformsType">
+ <sequence>
+ <element ref="ds:Transform" maxOccurs="unbounded"/>
+ </sequence>
+ </complexType>
+
+ <element name="Transform" type="ds:TransformType"/>
+ <complexType name="TransformType" mixed="true">
+ <choice minOccurs="0" maxOccurs="unbounded">
+ <any namespace="##other" processContents="lax"/>
+ <!-- (1,1) elements from (0,unbounded) namespaces -->
+ <element name="XPath" type="string"/>
+ </choice>
+ <attribute name="Algorithm" type="anyURI" use="required"/>
+ </complexType>
+
+<!-- End Reference -->
+
+<element name="DigestMethod" type="ds:DigestMethodType"/>
+<complexType name="DigestMethodType" mixed="true">
+ <sequence>
+ <any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+ </sequence>
+ <attribute name="Algorithm" type="anyURI" use="required"/>
+</complexType>
+
+<element name="DigestValue" type="ds:DigestValueType"/>
+<simpleType name="DigestValueType">
+ <restriction base="base64Binary"/>
+</simpleType>
+
+<!-- End SignedInfo -->
+
+<!-- Start KeyInfo -->
+
+<element name="KeyInfo" type="ds:KeyInfoType"/>
+<complexType name="KeyInfoType" mixed="true">
+ <choice maxOccurs="unbounded">
+ <element ref="ds:KeyName"/>
+ <element ref="ds:KeyValue"/>
+ <element ref="ds:RetrievalMethod"/>
+ <element ref="ds:X509Data"/>
+ <element ref="ds:PGPData"/>
+ <element ref="ds:SPKIData"/>
+ <element ref="ds:MgmtData"/>
+ <any processContents="lax" namespace="##other"/>
+ <!-- (1,1) elements from (0,unbounded) namespaces -->
+ </choice>
+ <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+
+ <element name="KeyName" type="string"/>
+ <element name="MgmtData" type="string"/>
+
+ <element name="KeyValue" type="ds:KeyValueType"/>
+ <complexType name="KeyValueType" mixed="true">
+ <choice>
+ <element ref="ds:DSAKeyValue"/>
+ <element ref="ds:RSAKeyValue"/>
+ <any namespace="##other" processContents="lax"/>
+ </choice>
+ </complexType>
+
+ <element name="RetrievalMethod" type="ds:RetrievalMethodType"/>
+ <complexType name="RetrievalMethodType">
+ <sequence>
+ <element ref="ds:Transforms" minOccurs="0"/>
+ </sequence>
+ <attribute name="URI" type="anyURI"/>
+ <attribute name="Type" type="anyURI" use="optional"/>
+ </complexType>
+
+<!-- Start X509Data -->
+
+<element name="X509Data" type="ds:X509DataType"/>
+<complexType name="X509DataType">
+ <sequence maxOccurs="unbounded">
+ <choice>
+ <element name="X509IssuerSerial" type="ds:X509IssuerSerialType"/>
+ <element name="X509SKI" type="base64Binary"/>
+ <element name="X509SubjectName" type="string"/>
+ <element name="X509Certificate" type="base64Binary"/>
+ <element name="X509CRL" type="base64Binary"/>
+ <any namespace="##other" processContents="lax"/>
+ </choice>
+ </sequence>
+</complexType>
+
+<complexType name="X509IssuerSerialType">
+ <sequence>
+ <element name="X509IssuerName" type="string"/>
+ <element name="X509SerialNumber" type="integer"/>
+ </sequence>
+</complexType>
+
+<!-- End X509Data -->
+
+<!-- Begin PGPData -->
+
+<element name="PGPData" type="ds:PGPDataType"/>
+<complexType name="PGPDataType">
+ <choice>
+ <sequence>
+ <element name="PGPKeyID" type="base64Binary"/>
+ <element name="PGPKeyPacket" type="base64Binary" minOccurs="0"/>
+ <any namespace="##other" processContents="lax" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </sequence>
+ <sequence>
+ <element name="PGPKeyPacket" type="base64Binary"/>
+ <any namespace="##other" processContents="lax" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </sequence>
+ </choice>
+</complexType>
+
+<!-- End PGPData -->
+
+<!-- Begin SPKIData -->
+
+<element name="SPKIData" type="ds:SPKIDataType"/>
+<complexType name="SPKIDataType">
+ <sequence maxOccurs="unbounded">
+ <element name="SPKISexp" type="base64Binary"/>
+ <any namespace="##other" processContents="lax" minOccurs="0"/>
+ </sequence>
+</complexType>
+
+<!-- End SPKIData -->
+
+<!-- End KeyInfo -->
+
+<!-- Start Object (Manifest, SignatureProperty) -->
+
+<element name="Object" type="ds:ObjectType"/>
+<complexType name="ObjectType" mixed="true">
+ <sequence minOccurs="0" maxOccurs="unbounded">
+ <any namespace="##any" processContents="lax"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+ <attribute name="MimeType" type="string" use="optional"/> <!-- add a grep facet -->
+ <attribute name="Encoding" type="anyURI" use="optional"/>
+</complexType>
+
+<element name="Manifest" type="ds:ManifestType"/>
+<complexType name="ManifestType">
+ <sequence>
+ <element ref="ds:Reference" maxOccurs="unbounded"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+
+<element name="SignatureProperties" type="ds:SignaturePropertiesType"/>
+<complexType name="SignaturePropertiesType">
+ <sequence>
+ <element ref="ds:SignatureProperty" maxOccurs="unbounded"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+
+ <element name="SignatureProperty" type="ds:SignaturePropertyType"/>
+ <complexType name="SignaturePropertyType" mixed="true">
+ <choice maxOccurs="unbounded">
+ <any namespace="##other" processContents="lax"/>
+ <!-- (1,1) elements from (1,unbounded) namespaces -->
+ </choice>
+ <attribute name="Target" type="anyURI" use="required"/>
+ <attribute name="Id" type="ID" use="optional"/>
+ </complexType>
+
+<!-- End Object (Manifest, SignatureProperty) -->
+
+<!-- Start Algorithm Parameters -->
+
+<simpleType name="HMACOutputLengthType">
+ <restriction base="integer"/>
+</simpleType>
+
+<!-- Start KeyValue Element-types -->
+
+<element name="DSAKeyValue" type="ds:DSAKeyValueType"/>
+<complexType name="DSAKeyValueType">
+ <sequence>
+ <sequence minOccurs="0">
+ <element name="P" type="ds:CryptoBinary"/>
+ <element name="Q" type="ds:CryptoBinary"/>
+ </sequence>
+ <element name="G" type="ds:CryptoBinary" minOccurs="0"/>
+ <element name="Y" type="ds:CryptoBinary"/>
+ <element name="J" type="ds:CryptoBinary" minOccurs="0"/>
+ <sequence minOccurs="0">
+ <element name="Seed" type="ds:CryptoBinary"/>
+ <element name="PgenCounter" type="ds:CryptoBinary"/>
+ </sequence>
+ </sequence>
+</complexType>
+
+<element name="RSAKeyValue" type="ds:RSAKeyValueType"/>
+<complexType name="RSAKeyValueType">
+ <sequence>
+ <element name="Modulus" type="ds:CryptoBinary"/>
+ <element name="Exponent" type="ds:CryptoBinary"/>
+ </sequence>
+</complexType>
+
+<!-- End KeyValue Element-types -->
+
+<!-- End Signature -->
+
+</schema>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig1-schema.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig1-schema.xsd
new file mode 100755
index 0000000000000000000000000000000000000000..b6eba2c2127d59e280e4581500f2615e356f1087
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig1-schema.xsd
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Service Metadata Publishing (SMP) Version 2.0
+ Committee Specification Draft 01 / Public Review Draft 01
+ 18 July 2018
+ Copyright (c) OASIS Open 2018. All Rights Reserved.
+ Source: http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/csprd01/xsd/common/
+ Latest version of narrative specification: http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/bdx-smp-v2.0.html
+ TC IPR Statement: https://www.oasis-open.org/committees/bdxr/ipr.php
+-->
+<!--
+ Library: OASIS Service Metadata Publisher (SMP) 2.0 CSD01WD01
+ http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/csd01wd01/
+ Release Date: 12 April 2018
+ Module: SMP-xmldsig1-schema-2.0.xsd
+ Generated on: 2017-12-06 21:00(UTC)
+
+ This is a copy of http://www.w3.org/TR/xmldsig-core1/xmldsig1-schema.xsd
+ changed only to correctly import the local copies of the included and
+ imported schema fragments.
+-->
+
+<!--
+#
+# Copyright ©[2011] World Wide Web Consortium
+# (Massachusetts Institute of Technology,
+# European Research Consortium for Informatics and Mathematics,
+# Keio University). All Rights Reserved.
+# This work is distributed under the W3C® Software License [1] in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE.
+# [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+-->
+
+<schema xmlns="http://www.w3.org/2001/XMLSchema"
+ targetNamespace="http://www.w3.org/2000/09/xmldsig#"
+ version="0.1" elementFormDefault="qualified">
+
+ <include
+ schemaLocation="xmldsig-core-schema.xsd"/>
+
+ <import namespace="http://www.w3.org/2009/xmldsig11#"
+ schemaLocation="xmldsig11-schema.xsd"/>
+</schema>
+
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig1-schema.xsd-old b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig1-schema.xsd-old
new file mode 100644
index 0000000000000000000000000000000000000000..e957baab737ba1d54d46ab84516d2918bd4955a4
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig1-schema.xsd-old
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+# This schema file is an updated version of the XML Signature 1.1 Schema Driver, published at:
+# https://www.w3.org/TR/2013/REC-xmldsig-core1-20130411/xmldsig1-schema.xsd
+#
+# That schema file relates to the W3C XML Signature 1.1 Recommendation and is referenced from:
+# https://www.w3.org/TR/2013/REC-xmldsig-core1-20130411/#sec-Schema
+#
+# The update addresses known errata in the XML Signature 1.1 Schema Driver file as noted in:
+# https://www.w3.org/2008/xmlsec/errata/xmldsig-core-11-errata.html
+#
+# The XML Signature 1.1 Schema Driver file includes the following copyright notice:
+#
+# Copyright ©[2011] World Wide Web Consortium
+# (Massachusetts Institute of Technology,
+# European Research Consortium for Informatics and Mathematics,
+# Keio University). All Rights Reserved.
+# This work is distributed under the W3C® Software License [1] in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE.
+# [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+-->
+
+<schema xmlns="http://www.w3.org/2001/XMLSchema"
+ targetNamespace="http://www.w3.org/2000/09/xmldsig#"
+ version="0.1" elementFormDefault="qualified">
+
+ <include
+ schemaLocation="http://www.w3.org/TR/2008/REC-xmldsig-core-20080610/xmldsig-core-schema.xsd"/>
+
+ <import namespace="http://www.w3.org/2009/xmldsig11#"
+ schemaLocation="http://www.w3.org/TR/2013/REC-xmldsig-core1-20130411/xmldsig11-schema.xsd"/>
+
+</schema>
+
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig11-schema.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig11-schema.xsd
new file mode 100755
index 0000000000000000000000000000000000000000..aa2480414ac6bd2376c4403be7bbbb10899bc680
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/commons/xmldsig11-schema.xsd
@@ -0,0 +1,163 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Service Metadata Publishing (SMP) Version 2.0
+ Committee Specification Draft 01 / Public Review Draft 01
+ 18 July 2018
+ Copyright (c) OASIS Open 2018. All Rights Reserved.
+ Source: http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/csprd01/xsd/common/
+ Latest version of narrative specification: http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/bdx-smp-v2.0.html
+ TC IPR Statement: https://www.oasis-open.org/committees/bdxr/ipr.php
+-->
+<!--
+ Library: OASIS Service Metadata Publisher (SMP) 2.0 CSD01WD01
+ http://docs.oasis-open.org/bdxr/bdx-smp/v2.0/csd01wd01/
+ Release Date: 12 April 2018
+ Module: SMP-xmldsig11-schema-2.0.xsd
+ Generated on: 2017-12-06 21:00(UTC)
+
+ This is a copy of http://www.w3.org/TR/xmldsig-core1/xmldsig11-schema.xsd
+ changed only to include this header information.
+-->
+
+<!--
+#
+# Copyright ©[2011] World Wide Web Consortium
+# (Massachusetts Institute of Technology,
+# European Research Consortium for Informatics and Mathematics,
+# Keio University). All Rights Reserved.
+# This work is distributed under the W3C® Software License [1] in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE.
+# [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+-->
+
+<schema xmlns="http://www.w3.org/2001/XMLSchema"
+ xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+ xmlns:dsig11="http://www.w3.org/2009/xmldsig11#"
+ targetNamespace="http://www.w3.org/2009/xmldsig11#"
+ version="0.1" elementFormDefault="qualified">
+
+ <import namespace="http://www.w3.org/2000/09/xmldsig#"/>
+
+ <element name="ECKeyValue" type="dsig11:ECKeyValueType"/>
+ <complexType name="ECKeyValueType">
+ <sequence>
+ <choice>
+ <element name="ECParameters" type="dsig11:ECParametersType"/>
+ <element name="NamedCurve" type="dsig11:NamedCurveType"/>
+ </choice>
+ <element name="PublicKey" type="dsig11:ECPointType"/>
+ </sequence>
+ <attribute name="Id" type="ID" use="optional"/>
+ </complexType>
+
+ <complexType name="NamedCurveType">
+ <attribute name="URI" type="anyURI" use="required"/>
+ </complexType>
+
+ <simpleType name="ECPointType">
+ <restriction base="ds:CryptoBinary"/>
+ </simpleType>
+
+ <complexType name="ECParametersType">
+ <sequence>
+ <element name="FieldID" type="dsig11:FieldIDType"/>
+ <element name="Curve" type="dsig11:CurveType"/>
+ <element name="Base" type="dsig11:ECPointType"/>
+ <element name="Order" type="ds:CryptoBinary"/>
+ <element name="CoFactor" type="integer" minOccurs="0"/>
+ <element name="ValidationData"
+ type="dsig11:ECValidationDataType" minOccurs="0"/>
+ </sequence>
+ </complexType>
+
+ <complexType name="FieldIDType">
+ <choice>
+ <element ref="dsig11:Prime"/>
+ <element ref="dsig11:TnB"/>
+ <element ref="dsig11:PnB"/>
+ <element ref="dsig11:GnB"/>
+ <any namespace="##other" processContents="lax"/>
+ </choice>
+ </complexType>
+
+ <complexType name="CurveType">
+ <sequence>
+ <element name="A" type="ds:CryptoBinary"/>
+ <element name="B" type="ds:CryptoBinary"/>
+ </sequence>
+ </complexType>
+
+ <complexType name="ECValidationDataType">
+ <sequence>
+ <element name="seed" type="ds:CryptoBinary"/>
+ </sequence>
+ <attribute name="hashAlgorithm" type="anyURI" use="required"/>
+ </complexType>
+
+ <element name="Prime" type="dsig11:PrimeFieldParamsType"/>
+ <complexType name="PrimeFieldParamsType">
+ <sequence>
+ <element name="P" type="ds:CryptoBinary"/>
+ </sequence>
+ </complexType>
+
+ <element name="GnB" type="dsig11:CharTwoFieldParamsType"/>
+ <complexType name="CharTwoFieldParamsType">
+ <sequence>
+ <element name="M" type="positiveInteger"/>
+ </sequence>
+ </complexType>
+
+ <element name="TnB" type="dsig11:TnBFieldParamsType"/>
+ <complexType name="TnBFieldParamsType">
+ <complexContent>
+ <extension base="dsig11:CharTwoFieldParamsType">
+ <sequence>
+ <element name="K" type="positiveInteger"/>
+ </sequence>
+ </extension>
+ </complexContent>
+ </complexType>
+
+ <element name="PnB" type="dsig11:PnBFieldParamsType"/>
+ <complexType name="PnBFieldParamsType">
+ <complexContent>
+ <extension base="dsig11:CharTwoFieldParamsType">
+ <sequence>
+ <element name="K1" type="positiveInteger"/>
+ <element name="K2" type="positiveInteger"/>
+ <element name="K3" type="positiveInteger"/>
+ </sequence>
+ </extension>
+ </complexContent>
+ </complexType>
+
+ <element name="DEREncodedKeyValue" type="dsig11:DEREncodedKeyValueType"/>
+ <complexType name="DEREncodedKeyValueType">
+ <simpleContent>
+ <extension base="base64Binary">
+ <attribute name="Id" type="ID" use="optional"/>
+ </extension>
+ </simpleContent>
+ </complexType>
+
+ <element name="KeyInfoReference" type="dsig11:KeyInfoReferenceType"/>
+ <complexType name="KeyInfoReferenceType">
+ <attribute name="URI" type="anyURI" use="required"/>
+ <attribute name="Id" type="ID" use="optional"/>
+ </complexType>
+
+ <element name="X509Digest" type="dsig11:X509DigestType"/>
+ <complexType name="X509DigestType">
+ <simpleContent>
+ <extension base="base64Binary">
+ <attribute name="Algorithm" type="anyURI" use="required"/>
+ </extension>
+ </simpleContent>
+ </complexType>
+
+</schema>
+
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/cppa3.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/cppa3.xsd
new file mode 100755
index 0000000000000000000000000000000000000000..8a42184a7ea9b9a9b9a46dbf1056555ab11905fd
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/cppa3.xsd
@@ -0,0 +1,6650 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Collaboration Protocol Profile and Agreement Version 3.0
+ Committee Specification 01
+ 24 September 2020
+
+ Copyright (c) OASIS Open 2020. All Rights Reserved.
+ Source: https://docs.oasis-open.org/ebcore/cppa/v3.0/cs01/
+ Latest version of narrative specification: https://docs.oasis-open.org/ebcore/cppa/v3.0/cppa-v3.0.html
+ TC IPR Statement: https://www.oasis-open.org/committees/ebcore/ipr.php
+-->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:cppa="http://docs.oasis-open.org/ebcore/ns/cppa/v3.0"
+ xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+ xmlns:h="http://www.w3.org/1999/xhtml" xmlns:dsig11="http://www.w3.org/2009/xmldsig11#"
+ xmlns:ebbp="http://docs.oasis-open.org/ebxml-bp/ebbp-2.0"
+ xmlns:xkms="http://www.w3.org/2002/03/xkms#"
+ targetNamespace="http://docs.oasis-open.org/ebcore/ns/cppa/v3.0" elementFormDefault="qualified"
+ attributeFormDefault="unqualified" version="3.0">
+
+ <xs:annotation>
+ <xs:documentation>
+ <p>This XML schema is part of the
+ <a href="http://docs.oasis-open.org/ebcore/cppa/v3.0/">OASIS CPPA3 specification</a>
+ developed by the <a href="https://www.oasis-open.org/committees/ebcore/">OASIS ebCore TC</a>.</p>
+ <p>Two elements defined in this schema can serve as root elements of CPPA3 XML documents:</p>
+ <ol>
+ <li>The <a href="#CPP">CPP</a> element defines a Collaboration Protocol Profile.</li>
+ <li>The <a href="#CPA">CPA</a> element defines a Collaboration-Protocol Agreement.</li>
+ </ol>
+ </xs:documentation>
+ </xs:annotation>
+
+ <!-- xs:import namespace="http://www.w3.org/XML/1998/namespace"
+ schemaLocation="https://www.w3.org/2009/01/xml.xsd"/ -->
+
+ <xs:import namespace="http://www.w3.org/2000/09/xmldsig#"
+ schemaLocation="commons/xmldsig1-schema.xsd"/>
+
+ <xs:import namespace="http://www.w3.org/2009/xmldsig11#"
+ schemaLocation="commons/xmldsig11-schema.xsd"/>
+
+ <xs:import namespace="http://docs.oasis-open.org/ebxml-bp/ebbp-2.0"
+ schemaLocation="commons/ebbp-2.0.4.xsd"/>
+
+ <xs:import namespace="http://www.w3.org/2002/03/xkms#"
+ schemaLocation="commons/xkms.xsd"/>
+
+ <!-- xs:import namespace="http://www.w3.org/XML/1998/namespace"
+ schemaLocation="https://www.w3.org/2009/01/xml.xsd"/>
+
+ <xs:import namespace="http://www.w3.org/2000/09/xmldsig#"
+ schemaLocation="http://docs.oasis-open.org/ebcore/ebcore-au/v1.0/cs01/schema/xmldsig1-schema.xsd"/>
+
+ <xs:import namespace="http://www.w3.org/2009/xmldsig11#"
+ schemaLocation="http://docs.oasis-open.org/ebcore/ebcore-au/v1.0/cs01/schema/xmldsig1-schema.xsd"/>
+
+ <xs:import namespace="http://docs.oasis-open.org/ebxml-bp/ebbp-2.0"
+ schemaLocation="http://docs.oasis-open.org/ebxml-bp/2.0.4/OS/schema/ebbp-2.0.4.xsd"/>
+
+ <xs:import namespace="http://www.w3.org/2002/03/xkms#"
+ schemaLocation="https://www.w3.org/TR/xkms2/Schemas/xkms.xsd"/ -->
+
+ <!-- Collaboration Protocol Profile -->
+
+ <xs:element name="CPP">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A Collaboration Protocol Profile (<a href="#CPP">CPP</a>) defines the capabilities of a
+ Party to engage in electronic business message exchange with other Parties.
+ These capabilities include both
+ technology and business capabilities, such as supported transport and messaging
+ protocols, and what business collaborations the party can participate in.</p>
+ <p>Unlike the CPPA version 2.0 schema, only a single <a href="#PartyInfo">PartyInfo</a>
+ element is allowed in a CPP. The use case of a party that has different party
+ identities, which may be associated with different service specifications or with
+ different channels, transports etc. can be addressed by using different CPP
+ documents for the party.
+ </p>
+ <p>A <a href="#CPP">CPP</a> MAY be signed by by the party involved and/or
+ by another party involved in the creation or distribution of the <a href="#CPP">CPP</a>.</p>
+ <p>The optional attributes <em>allowed</em> and <em>denied</em> in the
+ <em>acl_attributes</em> attribute group MAY be attached at the <a href="#CPP">CPP</a>,
+ <a href="#ServiceBinding">ServiceBinding</a>, or
+ <a href="#ActionBinding">ActionBinding</a> levels. These attributes control
+ possibilities for CPA formation of the CPP with counterparty CPPs.
+ </p>
+ <p>If no <a href="#ServiceSpecification">ServiceSpecification</a> is present in the CPP,
+ the party indicates that it is unable to participate in electronic business message
+ exchange.
+ </p>
+ <p>The <a href="#CPPAExtension">CPPAExtension</a> element can be used for extensibility
+ of <a href="#CPP">CPP</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:ProfileInfo"/>
+ <xs:element ref="cppa:PartyInfo"/>
+ <xs:element ref="cppa:ServiceSpecification" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PropertySet" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Channel" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ChannelFeature" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Transport" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PayloadProfile" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Packaging" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PartyIdList" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="ds:Signature" minOccurs="0"/>
+ <xs:element ref="cppa:CPPAExtension" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attributeGroup ref="cppa:acl_attributes"/>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="CPPAExtension" abstract="true" type="cppa:CPPAExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract top level CPP or CPA Extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="CPPAExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract CPPA Extension type</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+ <!-- Elements and Types only used in a CPP -->
+
+ <xs:element name="ProfileInfo">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#ProfileInfo">ProfileInfo</a> element provides metadata about
+ the Collaboration Protocol Profile.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:ProfileIdentifier"/>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:ActivationDate" minOccurs="0"/>
+ <xs:element ref="cppa:ExpirationDate" minOccurs="0"/>
+ <xs:element ref="cppa:PhaseIn" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ProfileIdentifier">
+ <xs:annotation>
+ <xs:documentation>
+ <p>In a <a href="#CPP">CPP</a>,
+ the <a href="#ProfileIdentifier">ProfileIdentifier</a> element is used to provide an
+ identifier for the profile.
+ When used in a <a href="#CPA">CPA</a>,
+ it identifies a profile that the collaboration protocol agreement relates to.</p>
+ <p>The combination of the type value and element content MUST be unique in the context of the
+ party to which it relates. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute name="type" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>type</em> attribute defines a namespace in which
+ the content of the <a href="#ProfileIdentifier">ProfileIdentifier</a>
+ element is to be interpreted.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="href" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An optional URL locating the referenced <a href="#CPP">CPP</a>. This
+ attribute MAY be used in a
+ <a href="#CPA">CPA</a> to express the location from which a
+ referenced <a href="#CPP">CPP</a> was or can be retrieved.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <!-- Party ID lists are used for white listing and black listing counter parties in CPPs -->
+
+ <xs:element name="PartyIdList">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines a list of party identifiers or (recursively) references to lists of party
+ identifiers. The list logically includes all <a href="#PartyId">PartyId</a>s included as
+ direct child elements of the <a href="#PartyIdList">PartyIdList</a> element, as well as
+ all <a href="#PartyId">PartyId</a>s
+ indirectly included as child elements of <a href="#PartyIdList">PartyIdList</a>s referenced
+ (possibly recursively) as <a href="#PartyIdListsRef">PartyIdListRef</a> child elements.
+ </p>
+ <p>Party Id lists are used for white listing and black listing counterparties in CPPs,
+ using the <em>allowed</em> and <em>denied</em> attributes. </p>
+ <p>Party Id list references MUST NOT be circular. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice minOccurs="1" maxOccurs="unbounded">
+ <xs:element ref="cppa:PartyId"/>
+ <xs:element ref="cppa:PartyIdListRef"/>
+ </xs:choice>
+ <xs:attribute name="id" type="xs:ID">
+ <xs:annotation>
+ <xs:documentation>A unique identifier of the party identifier list.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="PartyIdListRef">
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="xs:string">
+ <xs:attribute name="href" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>A reference to a <a href="#PartyIdList">PartyIdList</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <!-- Collaboration Protocol Agreement -->
+
+ <xs:element name="CPA">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A Collaboration-Protocol Agreement (<a href="#CPA">CPA</a>) defines a set of specified
+ services and roles that a <a href="#Party">Party</a> and a
+ <a href="#CounterParty">CounterParty</a> agree upon to deploy, acting in agreed roles,
+ using particular <a href="#Channel">Channel</a>s and <a href="#Transport">Transport</a>s,
+ to exchange particular profiled <em>Payloads</em> using particular
+ <a href="#Packaging">Packaging</a>. A <a href="#CPA">CPA</a> MAY be signed by the
+ parties involved and/or by any other parties involved in the formation of
+ the <a href="#CPA">CPA</a>.
+ </p>
+ <p>Unlike the CPPA version 2.0 schema, only a single <a href="#PartyInfo">PartyInfo</a>
+ element is allowed in a CPA. A CPA also includes only a single
+ <a href="#CounterPartyInfo">CounterPartyInfo</a> element.
+ </p>
+ <p>The <a href="#CPPAExtension">CPPAExtension</a> element can be used for extensibility of
+ <a href="#CPA">CPA</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:AgreementInfo" minOccurs="0" maxOccurs="1"/>
+ <xs:element ref="cppa:PartyInfo" minOccurs="1" maxOccurs="1"/>
+ <xs:element ref="cppa:CounterPartyInfo" minOccurs="1" maxOccurs="1"/>
+ <xs:element ref="cppa:ServiceSpecification" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PropertySet" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Channel" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ChannelFeature" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Transport" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PayloadProfile" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Packaging" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="ds:Signature" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:CPPAExtension" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <!-- Elements and Types only used in a CPA -->
+
+ <xs:element name="AgreementInfo">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#AgreementInfo">AgreementInfo</a> element provides metadata about
+ the <a href="#CPA">CPA</a>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:annotation/>
+ <xs:sequence>
+ <xs:element ref="cppa:AgreementIdentifier"/>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:ProfileIdentifier" minOccurs="0" maxOccurs="2"/>
+ <xs:element ref="cppa:ActivationDate" minOccurs="0"/>
+ <xs:element ref="cppa:ExpirationDate" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="AgreementIdentifier">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The AgreementIdentifier element is used to provide an identifier for the agreement.
+ The type value and element content of the element MUST be unique in the context of the pair of
+ parties to which it relates.</p>
+ <p>Communities MAY adopt format conventions for the value of the
+ <a href="#AgreementIdentifier">AgreementIdentifier</a> element.
+ For example, the value MAY be derived from the values of two
+ <a href="#CPP">CPP</a> <a href="#ProfileIdentifier">ProfileIdentifier</a>s (if
+ the <a href="#CPA">CPA</a>
+ is formed from <a href="#CPP">CPP</a>) or from the <em>(Counter)PartyInfo/PartyId</em>
+ values in the <a href="#CPA">CPA</a>. <a href="#CPA">CPA</a> tooling MAY allow users
+ to specify and apply specific conventions.
+ </p>
+ <p>The element corresponds, for ebMS2, to the <em>CPAId</em> message header</p>
+ <p>For ebMS3, it naturally corresponds to the <em>PMode.Agreement</em> parameter
+ and <em>AgreementRef</em> header. However, that parameter and header are sometimes
+ used to specify adherence to multilateral, community agreements. In that case, they
+ are then more like a CPPA3 <a href="#ChannelProfile">ChannelProfile</a> indicator.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute name="type" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>type</em> attribute defines a namespace in which
+ the value of <a href="#AgreementIdentifier">AgreementIdentifier</a>
+ is to be interpreted.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ActivationDate" type="xs:dateTime">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used in a <a href="#CPP">CPP</a> or
+ <a href="#CPA">CPA</a>, this element defines the date and time from which the <a href="#CPP">CPP</a> or
+ <a href="#CPA">CPA</a> is valid.</p>
+ <p>When used in a <a href="#ServiceBinding">ServiceBinding</a>,
+ this element defines the date and time from which the <a href="#ServiceBinding">ServiceBinding</a>
+ is valid.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ExpirationDate" type="xs:dateTime">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used in a <a href="#CPP">CPP</a> or
+ <a href="#CPA">CPA</a>,
+ this element defines the date and time at which a <a href="#CPP">CPP</a> or
+ <a href="#CPA">CPA</a> expires.</p>
+ <p>When used in a <a href="#ServiceBinding">ServiceBinding</a>,
+ this element defines the date and time from which a <a href="#ServiceBinding">ServiceBinding</a>
+ expires.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="PhaseIn" type="xs:duration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines the minimum interval needed to phase in an agreement created from a
+ a collaboration protocol profile. This element MAY be useful if deployment of a
+ <a href="#CPA">CPA</a> in a company involves a service management process that is
+ not a (fully) automated process.
+ When forming an agreement for two profiles, the longest
+ of the intervals specified in the two profiles is to be used.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <!-- Common elements and types -->
+
+ <xs:element name="PartyInfo" type="cppa:PartyInfoType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#PartyInfo">PartyInfo</a> element provides information about a Party.
+ This element is used in <a href="#CPP">CPP</a> and <a href="#CPA">CPA</a>.
+ </p>
+ <p>When used for ebMS3, this element encodes some information relating to the
+ <em>PMode.{Initiator/Responder}.Party</em> parameters.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="CounterPartyInfo" type="cppa:PartyInfoType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#CounterPartyInfo">CounterPartyInfo</a> element provides information
+ about a CounterParty. This element is only used in <a href="#CPA">CPA</a>.</p>
+ <p>When used for ebMS3, this element encodes some information relating to the
+ <em>PMode.{Initiator/Responder}.Party</em> parameters.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="PartyInfoType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>For a Party or CounterParty, its <em>Name</em>
+ <em>ID</em>s, <em>Contact</em> information, any certificates, trusted anchors,
+ certificate policies and IDPs used by the party MAY be specified. </p>
+ <p>The semantics of presence of more than one <a href="#PartyName">PartyName</a> is
+ out of scope for this specification.
+ </p>
+ <p>If more than one child <a href="#PartyId">PartyId</a> element is used in a CPPA3
+ document for a party, any or all party identifiers MAY be used to identify the party.
+ If more than one <a href="#PartyId">PartyId</a> element is used in a CPPA3 document
+ for a party,
+ presence of any or all related headers in related messages configured using
+ the CPPA3 document is dependent on the channel (which may or may not allow or require
+ presence of multiple party identifiers), channel profile, and/or implementation used.
+ </p>
+ <p>The <a href="#PartyInfoExtension">PartyInfoExtension</a> element can be used for
+ extensibility of <a href="#PartyInfo">PartyInfo</a> and
+ <a href="#CounterPartyInfo">CounterPartyInfo</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:PartyName" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PartyId" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PartyContact" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Certificate" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:TrustAnchorSet" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:CertificatePolicySet" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:CertificateDefaults" minOccurs="0"/>
+ <xs:element ref="cppa:IDPRegistration" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:IDPRegistrationSet" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:SSHKey" minOccurs="0" maxOccurs="unbounded"></xs:element>
+ <xs:element ref="cppa:PartyInfoExtension" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="href" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>href</em> attribute provides a link, in the form of a URI, to additional
+ information about the Party or CounterParty. Typically, this would be a URL
+ from which the information can be obtained. The content and/or format of that
+ information at that URI is outside of the scope of this specification.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:element name="PartyInfoExtension" abstract="true" type="cppa:PartyInfoExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract PartyInfo Extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="PartyInfoExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract PartyInfo Extension type</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+ <xs:element name="PartyName">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element indicates the common, human readable name of the organization.
+ The value of each <a href="#PartyName">PartyName</a> MUST identify the
+ organization, entity, division or group of an organization described in the
+ parent
+ <a href="#PartyInfo">PartyInfo</a> element in
+ the <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a> document.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <!-- xs:attribute ref="xml:lang" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The language of the name.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute -->
+ <xs:attribute name="href" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An optional reference to a resource about the named Party.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="PartyId" type="cppa:PartyIdType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#PartyId">PartyId</a> element provides a party identifier for a
+ <em>(Counter)Party</em>.
+ This identifier is to be used to logically identify the Party.
+ The value of the <a href="#PartyId">PartyId</a> element is a non-empty string.
+ </p>
+ <p>When using the ebMS2 or ebMS3 protocols, the values of <a href="#PartyId">PartyId</a>
+ MUST be used as
+ <em>eb:From/eb:PartyId</em> and <em>eb:To/eb:PartyId</em> elements.
+ Note that these protocols require the <a href="#PartyId">PartyId</a> to be a URI
+ if the <em>type</em> attribute is not present.
+ </p>
+ <p>When using the AS2 or AS3 protocols, the values of <a href="#PartyId">PartyId</a>
+ MUST be used as
+ <em>AS2-From</em> and <em>AS2-To</em> and <em>AS3-From</em>
+ and <em>AS3-To</em> system identifier headers, respectively.</p>
+ <p>When using the AMQP protocol, the of <a href="#PartyId">PartyId</a>
+ SHOULD be used as the <em>user-id</em> and <em>to</em> message properties.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="PartyIdType">
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute name="type" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>type</em> attribute defines a namespace in which
+ the value of <a href="#PartyId">PartyId</a> is to be interpreted.
+ Use of the <a
+ href="http://docs.oasis-open.org/ebcore/PartyIdType/v1.0/">OASIS
+ ebCore Party Id Type specification</a>
+ is RECOMMENDED.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+
+ <xs:element name="PartyContact">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A person or department that acts as a point of contact for a party.</p>
+ <p>The content of this element is derived from the UN/CEFACT Core Component Library.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="ContactType" minOccurs="0" maxOccurs="1"
+ type="cppa:PartyContactType">
+ <xs:annotation>
+ <xs:documentation>The type of contact, e.g. business contact, technical contact,
+ security contact, administrative contact</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DepartmentName" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The name, expressed as text, of the department
+ to which this party contact belongs.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="PersonName" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The name, expressed as text, of the person
+ for this party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="JobTitle" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The job title, expressed as text, for this
+ party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DirectTelephone" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The direct unstructured telephone communication
+ information for this party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MobileTelephone" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The mobile unstructured telephone communication
+ information for this party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Fax" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The fax unstructured telecommunication information
+ for this party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Email" minOccurs="0" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The email communication information for this party
+ contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="URICommunication" minOccurs="0" maxOccurs="unbounded"
+ type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>Uniform Resource Identifier (URI) communication
+ information for this party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ <xs:attribute name="id">
+ <xs:annotation>
+ <xs:documentation>The unique identifier of this party contact.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:simpleType name="PartyContactType">
+ <xs:annotation>
+ <xs:documentation>The type of party contact. The XML type predefines four common
+ values and adds an option to define arbitrary other values.</xs:documentation>
+ </xs:annotation>
+ <xs:union>
+ <xs:simpleType>
+ <xs:annotation>
+ <xs:documentation/>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:enumeration value="Business Contact">
+ <xs:annotation>
+ <xs:documentation>A contact for the party for business related issues</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="Technical Contact">
+ <xs:annotation>
+ <xs:documentation>A contact for the party for technical issues</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="Security Contact">
+ <xs:annotation>
+ <xs:documentation>A contact for the party for security issues</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="Admin Contact">
+ <xs:annotation>
+ <xs:documentation>A contact for the party for administrative issues</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ <xs:simpleType>
+ <xs:annotation>
+ <xs:documentation>Alternative option to allow any other type of contact.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:minLength value="1"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:union>
+ </xs:simpleType>
+
+
+ <!-- Security Tokens and Certificates -->
+
+ <xs:element name="SecurityToken" abstract="true" type="cppa:SecurityTokenType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An abstract Security Token</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SecurityTokenType" abstract="true">
+ <xs:attribute name="id" type="xs:ID">
+ <xs:annotation>
+ <xs:documentation>A unique identifier for the security token.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:element name="SecurityTokenRef" type="cppa:SecurityTokenRefType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A abstract reference to a security token.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SecurityTokenRefType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Type definition of an abstract reference to a security token.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+ <xs:element name="Certificate" substitutionGroup="cppa:SecurityToken">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies an X.509 Certificate.</p>
+ <p>A certificate can be specified in one of two ways:</p>
+ <ol>
+ <li>The certificate can be included in the <a href="#CPP">CPP</a> or
+ <a href="#CPA">CPA</a> using an XML Signature
+ <em>KeyInfo</em> element.</li>
+ <li>The certificate can be referenced, using an XML Key Management Service (XKMS)
+ 2.0 <em>LocateRequest</em>. In some use cases, this request obviates the need
+ to include the certificate in
+ the <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a> document.
+ </li>
+ </ol>
+ <p>While this schema uses an XKMS schema element, use of the XKMS protocol and the XKMS
+ client and server software is NOT REQUIRED. Instead, the element is only used to specify
+ requirements on the certificate such that a certificate that is not included in the
+ <a href="#CPP">CPP</a> or
+ <a href="#CPA">CPA</a> document can be located.
+ In <a href="#CPA">CPA</a> formation, a matching certificate MAY be
+ selected using either by executing a XKMS <em>LocateRequest</em> against an XKMS server, or
+ using some other mechanism. Any certificate obtained from this SHOULD be matched against
+ any specified applicable trust anchors.
+ Any use the resulting certificate, if one is successfully retrieved in <a href="#CPA">CPA</a>
+ formation, is left to
+ implementations or usage profiles. For example, an implementation MAY include the
+ retrieved certificate instead of the <em>LocateRequest</em> in the formed <a href="#CPA">CPA</a>.
+ </p>
+ <p>In XKMS, the <em>Service</em> attribute is mandatory. If its value is non-empty, it MAY be set to
+ the value of the URI to which an XKMS request locating the certificate is to be directed.
+ Alternatively, the value MAY be used as a configuration parameter for locating the
+ certificate.
+ If the
+ value is empty (as allowed by the <em>anyURI</em> data type), the source from which the certificate is
+ to be retrieved is not expressed and its interpretation and use are implementation-dependent.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenType">
+ <xs:choice>
+ <xs:element ref="ds:KeyInfo"/>
+ <xs:element ref="xkms:LocateRequest"/>
+ </xs:choice>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="CertificateRef" type="cppa:CertificateRefType" abstract="true"
+ substitutionGroup="cppa:SecurityTokenRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An abstract reference to a certificate.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="CertificateRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Type definition of an abstract reference to a certificate.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenRefType">
+ <xs:attribute name="certId" type="xs:IDREF" use="required"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+ <xs:element name="AnchorCertificateRef" type="cppa:CertificateRefType"
+ substitutionGroup="cppa:CertificateRef">
+ <xs:annotation>
+ <xs:documentation>A reference to a trusted Certification Authority.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="CertificateDefaults">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#CertificateDefaults">CertificateDefaults</a> element expresses
+ default certificates and default trust anchors for a
+ <a href="#Party">Party</a> in a CPP or CPA.
+ </p>
+ <p>For <a href="#Channel">Channel</a>s bound to <em>send</em>
+ <a href="#ActionBinding">ActionBinding</a>s that can be secured using
+ certificates:</p>
+ <ul>
+ <li>The <a href="#SigningCertificateRef">SigningCertificateRef</a> element
+ specifies the default certificate for message layer signing.
+ </li>
+ <li>The <a href="#EncryptionTrustAnchorSetRef">EncryptionTrustAnchorSetRef</a> element
+ specifies the default trust anchor set for any certificate to be used for
+ message layer encryption.</li>
+ </ul>
+ <p>For <a href="#Channel">Channel</a>s bound to <em>receive</em>
+ <a href="#ActionBinding">ActionBinding</a>s that can be secured using
+ certificates:</p>
+ <ul>
+ <li>The <a href="#EncryptionCertificateRef">EncryptionCertificateRef</a> element
+ specifies the default certificate for message layer encryption. </li>
+ <li>The <a href="#SigningTrustAnchorSetRef">SigningTrustAnchorSetRef</a> element
+ specifies the default trust anchor set for any certificate to be used for
+ message layer signing.</li>
+ </ul>
+ <p>For a Transport for which a Party acts as Server:</p>
+ <ul>
+ <li>The <a href="#ServerCertificateRef">ServerCertificateRef</a> specifies
+ the default server authentication certificate.</li>
+ <li>The <a href="#ClientTrustAnchorSetRef">ClientTrustAnchorSetRef</a>
+ specifies the default client trust anchor.</li>
+ </ul>
+ <p>For a Transport for which a Party acts as Client:</p>
+ <ul>
+ <li>The <a href="#ClientCertificateRef">ClientCertificateRef</a>
+ specifies the default client authentication certificate.</li>
+ <li>The <a href="#ServerTrustAnchorSetRef">ServerTrustAnchorSetRef</a>
+ specifies the default server trust anchor.</li>
+ </ul>
+ <p>For the purpose of forming a CPA from two CPPs, a definition in a CPP
+ of a <a href="#Channel">Channel</a>
+ for which a certificate or trust anchor for a <a href="#Party">Party</a> for
+ signing or encryption
+ is explicitly specified at the
+ level of a <a href="#ChannelFeature">ChannelFeature</a> for that
+ <a href="#Channel">Channel</a>
+ is equivalent to a <a href="#Channel">Channel</a> for which the certificate
+ or trust anchor
+ is not specified for the purpose at the
+ level of a <a href="#ChannelFeature">ChannelFeature</a> for that
+ <a href="#Channel">Channel</a>
+ but is specified for the purpose in the
+ <a href="#CertificateDefaults">CertificateDefaults</a> for the
+ <a href="#Party">Party</a> .
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:SigningCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:SigningTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:SigningCertificatePolicySetRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificatePolicySetRef" minOccurs="0"/>
+ <xs:element ref="cppa:ClientCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:ClientTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:ClientCertificatePolicySetRef" minOccurs="0"/>
+ <xs:element ref="cppa:ServerCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:ServerTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:ServerCertificatePolicySetRef" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:complexType name="CertificatePolicySetReferenceType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An reference to a set of certificate policies.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleContent>
+ <xs:extension base="xs:string">
+ <xs:attribute name="setId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A referenced identifier of a set of <a
+ href="#CertificatePolicies">CertificatePolicies</a>.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+
+
+ <xs:element name="TrustAnchorSet">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#TrustAnchorSet">TrustAnchorSet</a> is a collection of trusted
+ certificate roots.
+ The TrustAnchorSet element MAY contain one or
+ more <a href="#AnchorCertificateRef">AnchorCertificateRef</a>
+ elements, each of which refers to a Certificate element (under
+ <a href="#PartyInfo">PartyInfo</a>
+ or <a href="#CounterPartyInfo">CounterPartyInfo</a>)
+ that represents a root certificate trusted by this Party.
+ These trusted root certificates are used in the
+ process of certificate path validation. If a certificate in question does not “chainâ€
+ to one of
+ this Party’s trust anchors, it is considered invalid.</p>
+ <p>A <a href="#TrustAnchorSet">TrustAnchorSet</a> MAY also contain such a root
+ certificate as direct child element.</p>
+ <p>A <a href="#TrustAnchorSet">TrustAnchorSet</a> can be referenced
+ using <a href="#SigningTrustAnchorSetRef">SigningTrustAnchorSetRef</a>,
+ <a href="#EncryptionTrustAnchorSetRef">EncryptionTrustAnchorSetRef</a>,
+ <a href="#ClientTrustAnchorSetRef">ClientTrustAnchorSetRef</a>
+ and <a href="#ServerTrustAnchorSetRef">ServerTrustAnchorSetRef</a> elements in
+ channel or transport binding definitions,
+ and taken into account during <a href="#CPA">CPA</a> formation. In
+ forming a <a href="#CPA">CPA</a>, a presented certificate MUST be matched
+ against a referenced anchor. The
+ <a href="#TrustAnchorSet">TrustAnchorSet</a> itself is not REQUIRED to be present
+ in the generated <a href="#CPA">CPA</a>, as the selected
+ certificate is trusted directly and specified in the <a href="#CPA">CPA</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:choice minOccurs="1" maxOccurs="unbounded">
+ <xs:element ref="cppa:AnchorCertificateRef"/>
+ <xs:element ref="cppa:Certificate"/>
+ </xs:choice>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Unique identifier of the set of trusted anchor certificates</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="CertificatePolicySet">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A set of accepted certificate policies, identified using
+ <em>OID</em> in dotted string notation.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="CertificatePolicy" minOccurs="1" maxOccurs="unbounded">
+ <xs:simpleType>
+ <xs:restriction base="xs:string">
+ <xs:pattern value="([0-9]+\.)*[0-9]+"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Unique identifier of the set of accepted certificate policies</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="IDPRegistration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#IDPRegistration">IDPRegistration</a> element represents a
+ registration of a Party with an Identity Service Provider. This element can be
+ used by parties in conjunction with a channel that uses SAML tokens to select an
+ IDP to obtain the token from.
+ </p>
+ <p>The mandatory <a href="#ProviderID">ProviderID</a> is an Entity Identifier (see
+ [SAML-CORE-2.0-OS], section 8.3.6) that uniquely
+ identifies the identity provider</p>
+ <p/>
+ <p>The optional <a href="#Endpoint">Endpoint</a> is the Endpoint URI of the identity
+ provider.</p>
+ <p>The optional <a href="#ReceiverID">ReceiverID</a> represents the identity under
+ which a party is known by the IDP. It is REQUIRED for any party that receives messages
+ using a channel that requires information from the IDP.
+ </p>
+ <p>The element corresponds to <em>/sp:SamlToken/sp:Issuer</em> in WS-SecurityPolicy
+ [WSSecurityPolicy13].</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:ProviderID"/>
+ <xs:element ref="cppa:IDPName" minOccurs="0"/>
+ <xs:element ref="cppa:Endpoint" minOccurs="0"/>
+ <xs:element ref="cppa:ReceiverID"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Unique identifier of the IDP registration</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="IDPName" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>The <a href="#IDPName">IDPName</a> provides a human-readable name
+ for an identity provider.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ProviderID" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The mandatory <a href="#ProviderID">ProviderID</a> is an Entity Identifier
+ (see [SAML-CORE-2.0-OS], section 8.3.6) that uniquely
+ identifies the identity provider.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ReceiverID" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The mandatory <a href="#ReceiverID">ReceiverID</a> is an Entity Identifier
+ (see [SAML-CORE-2.0-OS], section 8.3.6) that specifies the identity under which a
+ Party is registered with the identity provider.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="IDPRegistrationRef">
+ <xs:annotation>
+ <xs:documentation>A reference to a trusted Identity Provider.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:attribute name="idp" type="xs:IDREF" use="required"/>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="IDPRegistrationSet">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#IDPRegistrationSet">IDPRegistrationSet</a> bundles a set of
+ IDP registrations and provides an identifier
+ that can be referenced by channels. Multiple registration sets MAY be specified,
+ for example to support cases where different sets of registrations apply to
+ different channels.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:IDPRegistrationRef" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Unique identifier of the set of IDP registrations</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="IDPRegistrationSetRef" type="cppa:IDPRegistrationSetRefType"
+ substitutionGroup="cppa:SecurityTokenRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a set of IDP registrations</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="IDPRegistrationSetRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Type definition of reference to a set of IDP registrations.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenRefType">
+ <xs:attribute name="idpsetid" type="xs:IDREF" use="required"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <!-- SSH keys and key references -->
+
+ <xs:element name="SSHKey" substitutionGroup="cppa:SecurityToken">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A Public Key for use with SSH2 [RFC4254].
+ The content of the public key MUST be included
+ as a <em>KeyInfo/KeyValue/DSAKeyValue</em> or
+ <em>KeyInfo/KeyValue/RSAKeyValue</em> element.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenType">
+ <xs:choice>
+ <xs:element ref="ds:KeyInfo"/>
+ </xs:choice>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SSHClientKeyRef" substitutionGroup="cppa:SecurityTokenRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to use of an SSH key for SSH client authentication.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenRefType">
+ <xs:attribute name="keyId" type="xs:IDREF" use="required"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SSHServerKeyRef" substitutionGroup="cppa:SecurityTokenRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to use of an SSH key for SSH server authentication.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenRefType">
+ <xs:attribute name="keyId" type="xs:IDREF" use="required"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+
+ <!-- Service Specification -->
+
+ <xs:element name="ServiceSpecification">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element associates a party with a <em>Service</em> and a binding (or bindings)
+ supporting the participation of the party in a particular role in one or multiple business
+ collaborations, collaborating with other parties acting in another particular role.
+ </p>
+ <p>In a <a href="#CPP">CPP</a>,
+ <a href="#PartyRole">PartyRole</a> specifies the role of the party defined in
+ <a href="#PartyInfo">PartyInfo</a>.
+ <a href="#CounterPartyRole">CounterPartyRole</a> specifies the role of an unspecified
+ party with whom the party MAY engage in message exchange.
+
+ </p>
+ <p>In a <a href="#CPA">CPA</a>,
+ <a href="#PartyRole">PartyRole</a> specifies the role of the party defined in
+ <a href="#PartyInfo">PartyInfo</a>
+ and <a href="#CounterPartyRole">CounterPartyRole</a>
+ specifies the role of the party defined in <a href="#CounterPartyInfo">CounterPartyInfo</a>.
+
+ </p>
+ <p>In a <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a> document, for an ordered
+ pair or <<a href="#PartyRole">PartyRole</a>, <a href="#CounterPartyRole">CounterPartyRole</a>>
+ all <a href="#ServiceBinding">ServiceBinding</a>s for that pair MUST be contained within a
+ single <a href="#ServiceSpecification">ServiceSpecification</a>.</p>
+
+ <p>In CPPA2, the equivalent of this element was called <em>CollaborationRole</em>.</p>
+ <p>The element <a href="#CounterPartyRole">CounterPartyRole</a> has no equivalent in CPPA2.
+ It is added the CPPA3 schema to facilitate
+ automated <a href="#CPA">CPA</a> formation in business processes involving more than two roles.
+ For example: In a collaboration involving roles <em>A</em>, <em>B</em> and <em>C</em>,
+ some message types may be exchanged between <em>A</em> and <em>B</em>, others between
+ <em>A</em> and <em>C</em> and others between <em>B</em> and <em>C</em>. Therefore in CPPA3
+ a <a href="#ServiceSpecification">ServiceSpecification</a>s specifies the involved role pair.
+ </p>
+ <p>The <a href="#ServiceSpecificationExtension">ServiceSpecificationExtension</a> element is
+ provided to allow extensibility of
+ <a href="#ServiceSpecification">ServiceSpecification</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:PartyRole"/>
+ <xs:element ref="cppa:CounterPartyRole"/>
+ <xs:element ref="cppa:ServiceBinding" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ServiceSpecificationExtension" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="base" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute kan be used to reference a business process definition document,
+ for example an OASIS ebBP schema document [ebBP]. Any references to collaborations,
+ transactions and roles in dependent <a href="#ServiceBinding">ServiceBinding</a>
+ elements are to be interpreted relative to this schema.
+ </p>
+ <p>This attribute serves the same purpose as the
+ use of <em>ProcessSpecification/ds:Reference</em> in CPPA2.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="uuid" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute uniquely identifies the business process associated with the
+ <a href="#ServiceSpecification">ServiceSpecification</a>.
+ If an ebBP document is referenced using the <em>base</em> attribute,
+ this value MUST match the UUID specified for a process contained in the referenced
+ ebBP document.
+ </p>
+ <p>This attribute is equivalent to the CPPA2 <em>ProcessSpecification/@uuid</em>
+ attribute.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="name" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute defines the name of the business process associated with the service
+ collaboration. If an ebBP document is referenced using the <em>base</em> attribute,
+ this value MUST match the name specified for a process contained in the referenced
+ ebBP document.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="version" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute defines the version of the business process associated with the
+ service collaboration.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attributeGroup ref="cppa:acl_attributes"/>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="ServiceSpecificationExtension" abstract="true"
+ type="cppa:ServiceSpecificationExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract ServiceSpecification Extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ServiceSpecificationExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract ServiceSpecification Extension type</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+
+ <xs:element name="PartyRole" type="cppa:RoleType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element identifies the role of the party involved in the service collaboration
+ in the sibling <a href="#ServiceBinding">ServiceBinding</a> elements.</p>
+ <p>With ebMS2 and ebMS3, this value is used in the <em>eb:From/eb:Role</em> or
+ <em>eb:To/Role</em> headers. </p>
+ <p>With ebMS3, depending on the exchange binding, this element corresponds to one of the
+ <em>PMode.Initiator.Role</em> or <em>PMode.Responder.Role</em> parameters.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="CounterPartyRole" type="cppa:RoleType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element identifies the role of the counterparty involved in the service collaboration
+ in the sibling <a href="#ServiceBinding">ServiceBinding</a> elements.</p>
+ <p>With ebMS2 and ebMS3, this value is used in <em>From/Role</em> or <em>To/Role</em> headers. </p>
+ <p>With ebMS3, depending on the exchange binding, this element corresponds to one of the
+ <em>PMode.Initiator.Role</em> or <em>PMode.Responder.Role</em> elements.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="RoleType">
+ <xs:attribute name="name" type="cppa:non-empty-string" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>For <a href="#ServiceBinding">ServiceBinding</a>s associated with a business process,
+ the value of this attribute MUST match a defined role in the business process.
+ </p>
+ <p>When used in combination with an ebBP process definition, the value of this attribute MUST
+ match a <em>BusinessCollaboration/Role/@name</em>, <em>BinaryCollaboration/Role/@name</em>
+ or <em>MultiPartyCollaboration/Role/@name</em> value.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:element name="ServiceBinding">
+ <xs:complexType>
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#ServiceBinding">ServiceBinding</a> specifies a <a href="#Service">Service</a>
+ and provides a binding of its actions. If a business process is referenced in the
+ parent <a href="#ServiceSpecification">ServiceSpecification</a>, this element
+ establishes the requesting and responding business activities
+ in a business process definition that describe the actions to be implemented.
+ </p>
+ <p>It is possible to specify the <a href="#ActivationDate">ActivationDate</a> for a <a href="#ServiceBinding">ServiceBinding</a>, if its value is later than the value of the
+ <a href="#ActivationDate">ActivationDate</a> of the containing
+ <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a>.
+ </p>
+ <p>Similarly, it is possible to specify the <a href="#ExpirationDate">ExpirationDate</a> for a <a href="#ServiceBinding">ServiceBinding</a>, if its value is earlier than the value of the
+ <a href="#ExpirationDate">ExpirationDate</a> of the containing
+ <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a>.
+ </p>
+ <p>The <a href="#ServiceBindingExtension">ServiceBindingExtension</a> element is provided to
+ allow extensibility of <a href="#ServiceBinding">ServiceBinding</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:Service"/>
+ <xs:element ref="cppa:ActivationDate" minOccurs="0"/>
+ <xs:element ref="cppa:ExpirationDate" minOccurs="0"/>
+ <xs:element ref="cppa:ActionBinding" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ServiceBindingExtension" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attributeGroup ref="cppa:acl_attributes"/>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ServiceBindingExtension" abstract="true"
+ type="cppa:ServiceBindingExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract ServiceBinding Extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ServiceBindingExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract ServiceBinding Extension type</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+ <xs:element name="Service">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element identifies the service that acts on the message. Its actual semantics is beyond
+ the scope of this specification. Its value MUST be agreed and interpreted consistently by
+ a party and its counterparties. The designer of a service may be a standards organization or
+ industry, an individual or enterprise.</p>
+ <p>In ebMS3, this element corresponds to the <em> PMode[1].BusinessInfo.Service</em>
+ parameter.</p>
+ <p>When used for a business process defined in ebBP, the value of this element
+ SHOULD match a <em>BusinessCollaboration/@name</em>, <em>BinaryCollaboration/@name</em>
+ or <em>MultiPartyCollaboration/@name</em> value in the context of the referenced
+ ebBP document.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute name="type" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation><p>The attribute define a service type.</p></xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ActionBinding">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An <a href="#ActionBinding">ActionBinding</a> defines a binding for an <em>action</em>
+ in a service. Its actual semantics is beyond the scope of this specification.
+ Like the ebMS3 concept of a <em>processing mode</em>, the binding controls the
+ way messages are processed and provides a configuration that is common to a set of messages
+ exchanged among parties.
+ </p>
+ <p>This version of CPPA
+ supports actions in <em>One Way</em> exchanges and pairs of actions in <em>Two Way</em>
+ exchanges. An action in a One Way exchange is an action that is not followed by another action
+ that explicitly relates to the One Way exchange action. In Two Way exchanges, one action is
+ expected to be followed by another action that explicitly relates to it. This other action
+ MUST reference the action it relates to using the <em>replyTo</em> attribute. The interpretation of
+ situations in which there are multiple <a href="#ActionBinding">ActionBinding</a>s that are
+ replies to the same <a href="#ActionBinding">ActionBinding</a>,
+ is outside the scope of this specification. They may constitute alternative responses.
+ For example, a <em>SubmitOrder</em> action may be replied to by an <em>AcceptOrder</em> action or
+ a <em>RejectOrder</em> action.
+ When used for actions defined in an ebBP schema document, a One Way exchange corresponds to a
+ <em>RequestingBusinessActivity</em>. A Two Way exchange corresponds to a
+ <em>RequestingBusinessActivity</em> and the corresponding <em>RespondingBusinessActivity</em>
+ </p>
+ <p>An <a href="#ActionBinding">ActionBinding</a> corresponds with an ebMS3 One Way MEP (identified as
+ <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/core/200704/oneWay</em>)
+ if there is no other <a href="#ActionBinding">ActionBinding</a> that refers to it using the
+ <em>replyTo</em> attribute.</p>
+ <p>An ebMS3 Two Way MEP
+ (identified as <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/core/200704/twoWay</em>)
+ corresponds to a collection of at least two <a href="#ActionBinding">ActionBinding</a>s.
+ Exactly one of these MUST
+ NOT have a <em>replyTo</em> attribute. This constitutes the first leg in the MEP. All other
+ <a href="#ActionBinding">ActionBinding</a>s in this collection relate to the second leg in
+ the message exchange.
+ They MUST have a <em>replyTo</em> reference to the <a href="#ActionBinding">ActionBinding</a> corresponding
+ to the first leg.
+ For ebMS3, specification of alternative responses is
+ <a href="https://issues.oasis-open.org/browse/EBXMLMSG-74">an issue</a> to possibly
+ be addressed in a future errata.
+ </p>
+ <p><a href="#ActionBinding">ActionBinding</a> elements with values <em>send</em>
+ or <em>receive</em> for the
+ <em>sendOrReceive</em> attribute correspond to the CPPA version 2.0 <em>CanSend</em>
+ and <em>CanReceive</em> elements, respectively. </p>
+ <p>In a <a href="#CPP">CPP</a>, an <a href="#ActionBinding">ActionBinding</a> is associated
+ with one or multiple channels,
+ identified using their <a href="#ChannelId">ChannelId</a>. If there is more than one
+ reference to a
+ channel, the presented channels are alternatives, with preferred bindings preceding
+ less preferred alternatives. For example, a party may offer an ebMS3 channel that is
+ preferred as well as an ebMS2 channel that is supported for legacy connections.
+ </p>
+ <p>In a <a href="#CPA">CPA</a>, there MUST be exactly one <a href="#ChannelID">ChannelID</a>,
+ covering the channel for both parties. </p>
+
+ <p>In a <a href="#CPP">CPP</a>, the CPPA3 schema associates an <a href="#ActionBinding">ActionBinding</a>
+ with zero or multiple payload profiles, identified using a
+ <a href="#PayloadProfileId">PayloadProfileId</a>. If there is more than one
+ reference to a
+ payload profile, the presented payload profiles are alternatives,
+ with preferred bindings preceding
+ less preferred alternatives.
+ In the absence of any <a href="#PayloadProfileId">PayloadProfileId</a> elements,
+ there are no contraints on payloads that are exchanged.</p>
+ <p>In a <a href="#CPA">CPA</a>, there MUST be at most one
+ <a href="#PayloadProfileId">PayloadProfileId</a>,
+ covering the payload profile that both parties agree to use.
+ In the absence of any <a href="#PayloadProfileId">PayloadProfileId</a> elements,
+ there are no contraints on payloads that are exchanged.
+ </p>
+
+ <p>When a <a href="#CPA">CPA</a> is used in combination with the ebMS2 or ebMS3 messaging
+ protocols, the <em>Service</em>
+ and <em>Action</em> message headers and the <a href="#Service">Service</a> element content
+ and the <em>action</em> attribute of <a href="#ActionBinding">ActionBinding</a>
+ in the CPA can be linked to infer the applicable <a href="#ActionBinding">ActionBinding</a>, with its
+ <a href="#Channel">Channel</a> and <a href="#PayloadProfile">PayloadProfile</a>.
+ This mapping is unambiguous if,
+ in the context of an <a href="#ServiceBinding">ServiceBinding</a>,
+ only a single <a href="#ActionBinding">ActionBinding</a> exists for any
+ given pair of values for the <em>action</em> and
+ <em>sendOrReceive</em> attributes.
+ </p>
+
+ <p>An <a href="#ActionBinding">ActionBinding</a> MAY contain <a href="#Property">Property</a>
+ elements that associate additional
+ metadata with the messages.
+
+ The semantics of these elements
+ MAY depend on the <a href="#Service">Service</a> context of the
+ <a href="#ActionBinding">ActionBinding</a>.
+ </p>
+ <p>The use of <a href="#Property">Property</a> elements MAY depend on the messaging protocol used.
+ In ebMS3, the elements control the use of Message Properties. In AMQP, they map to
+ AMQP Application Properties.
+ </p>
+ <p>
+ Sets of <a href="#Property">Property</a> elements MAY also be referenced using
+ the <em>propertySetId</em> attribute.
+ If any <a href="#Property">Property</a> elements are present, the <em>propertySetId</em>
+ attribute MUST NOT be
+ present.
+ </p>
+ <p>The <a href="#ActionBindingExtension">ActionBindingExtension</a> element is provided to allow
+ extensibility of <a href="#ActionBinding">ActionBinding</a> elements.</p>
+
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:ChannelId" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:PayloadProfileId" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Property" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ActionBindingExtension" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>id</em> attribute identifies an <a href="#ActionBinding">ActionBinding</a>
+ in the context of a CPPA3 document.
+ This enables cross-references between actions using the <em>replyTo</em> attribute.
+ The attribute can also serve a similar purpose to
+ the ebMS3 <em>PMode.ID</em> parameter, however the ebMS3 parameter is common to the two
+ legs in a Two Way MEP, whereas the CPPA3 attribute is specific to a particular leg.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="action" type="xs:anyURI" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used for actions defined in an ebBP schema document, the value of this
+ attribute SHOULD match a <em>RequestingBusinessActivity/@name</em> or
+ <em>RespondingBusinessActivity/@name</em> value.
+ </p>
+ <p>When used with ebMS3, the <em>action</em> attribute corresponds to the
+ ebMS3 <em>PMode[1].BusinessInfo.Action</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="businessTransactionActivity" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used for actions defined in an ebBP schema document, the value of this
+ attribute MUST match <em>ComplexBusinessTransactionActivity/@name</em> or
+ <em>BusinessTransactionActivity/@name</em>
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="collaborationActivity" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used for actions defined in an ebBP schema document, the value of this
+ attribute MUST match a defined <em>CollaborationActivity/@name</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="requestOrResponseAction" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used for actions defined in an ebBP schema document, the value of this
+ attribute MUST match a defined <em>RequestingBusinessActivity/@name</em>
+ or the <em>RespondingBusinessActivity/@name</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attributeGroup ref="ebbp:quality">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute group specifies business quality of service attributes for the action.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attributeGroup>
+ <xs:attribute name="sendOrReceive" use="required" type="cppa:send_or_receive_type">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute specifies the directionality of the action, from the perspective of the Party.
+ In a pair of actions in a Two Way exchange, if the value of
+ <em>sendOrReceive</em> for the first
+ action is <em>send</em>, the second action MUST have the value
+ <em>receive</em> and vice versa.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="replyTo" type="xs:IDREF" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute MAY be used to express that an action is a response to some
+ other action and to identify that action. When bound to ebMS2 or ebMS3,
+ this attribute also expresses that on messages for this action
+ a <em>RefToMessageId</em> element is REQUIRED.
+ </p>
+ <p>If <a href="#ActionBinding">ActionBinding</a> X references another
+ <a href="#ActionBinding">ActionBinding</a> Y
+ using <em>replyTo</em>, then Y MUST NOT itself
+ reference any other <a href="#ActionBinding">ActionBinding</a> Z.
+ </p>
+ <p>A referenced <a href="#ActionBinding">ActionBinding</a> MUST be a
+ sibling element, i.e. it MUST be
+ contained in the same <a href="#ServiceBinding">ServiceBinding</a>.
+ As a consequence, when used with
+ ebMS2 or ebMS3, the value for the <em>Service</em> header field will be the same for
+ both legs in a Two Way MEP. Also see <a href="https://issues.oasis-open.org/browse/EBXMLMSG-73">https://issues.oasis-open.org/browse/EBXMLMSG-73</a>.
+ </p>
+ <p>When used for actions defined in an ebBP schema document, this attribute MUST be
+ present on actions representing a <em>RespondingBusinessActivity</em> and MUST
+ reference an <em>ActionBinding/@id</em> for the corresponding
+ <em>RequestingBusinessActivity</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="use" use="optional" default="required" type="cppa:usetype">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute MUST NOT be used in a <a href="#CPA">CPA</a>.
+ It MAY be used in a <a href="#CPP">CPP</a> to express whether
+ or not support for the action is required, in the context of a containing
+ <a href="#ServiceBinding">ServiceBinding</a>.
+ If a <a href="#CPP">CPP</a> specifies its use as optional, the
+ other <a href="#CPP">CPP</a>
+ does not have to provide an <a href="#ActionBinding">ActionBinding</a>
+ for the <em>action</em> for
+ the match of the service binding to succeed.
+ </p>
+ <p>If the other <a href="#CPP">CPP</a> does provide an
+ <a href="#ActionBinding">ActionBinding</a> for that action that does
+ not specify its <em>use</em> to be <em>optional</em>, then the two
+ <a href="#ActionBinding">ActionBinding</a>s MUST match for the
+ <a href="#ServiceBinding">ServiceBinding</a> to match.
+ </p>
+ <p>If the other <a href="#CPP">CPP</a> does provide an <a href="#ActionBinding">ActionBinding</a> for that action that
+ specifies its <em>use</em> to be <em>optional</em>, then the two <a href="#ActionBinding">ActionBinding</a>s
+ are not REQUIRED to match. If there is a match, the result of the match MUST be
+ included in the resulting <a href="#ServiceBinding">ServiceBinding</a>.
+ </p>
+ <p>Absence of this attribute in a <a href="#CPP">CPP</a> is equivalent
+ to it being present with value
+ <em>required</em>, i.e. by default specified actions are required within the
+ scope of a service binding.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="propertySetId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a <a href="#PropertySet">PropertySet</a>.
+ If this attribute is present in an
+ <a href="#ActionBinding">ActionBinding</a>, there MUST NOT be
+ any <a href="#Property">Property</a> child elements.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attributeGroup ref="cppa:acl_attributes"/>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ActionBindingExtension" abstract="true" type="cppa:ActionBindingExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract ActionBinding Extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ActionBindingExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract ActionBinding Extension type</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+
+ <xs:simpleType name="send_or_receive_type">
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="send"/>
+ <xs:enumeration value="receive"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+ <xs:element name="PayloadProfileId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#PayloadProfileId">PayloadProfileId</a> identifies a payload profile that MAY be
+ used in the exchange of message for an <a href="#ActionBinding">ActionBinding</a>. </p>
+ <p>In a <a href="#CPP">CPP</a>, multiple occurrences of <a href="#PayloadProfileId">PayloadProfileId</a> MAY be specified in
+ an <a href="#ActionBinding">ActionBinding</a>. A sequence of
+ two or more <a href="#PayloadProfileId">PayloadProfileId</a> elements expresses alternative
+ payload profiles which the party is willing to use for
+ the <a href="#ActionBinding">ActionBinding</a>. The semantics
+ of the order corresponds to a preference. If <a href="#PayloadProfileId">PayloadProfileId</a> <b>X</b>
+ preceeds <a href="#PayloadProfileId">PayloadProfileId</a> <b>Y</b> within the scope of an <a href="#ActionBinding">ActionBinding</a>, then the
+ Party prefers use of <b>X</b> over <b>Y</b> for the specified action.
+ </p>
+ <p>In a <a href="#CPA">CPA</a>, at most
+ one <a href="#PayloadProfileId">PayloadProfileId</a> MUST be present.
+ It identifies the payload profile that
+ Party and CounterParty agree to bind the specified action to.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#ChannelId">ChannelId</a> identifies a channel that MAY be used to exchange
+ a message in the context of a CPPA3 document. </p>
+ <p>In a <a href="#CPP">CPP</a>, multiple occurrences of <a href="#ChannelId">ChannelId</a> MAY be specified in an
+ <a href="#ActionBinding">ActionBinding</a>. A sequence of
+ two or more <a href="#ChannelId">ChannelId</a> elements expresses alternative
+ channels which the party is willing to use for the message exchange. The semantics
+ of the order corresponds to a preference. If <a href="#ChannelId">ChannelId</a> <b>X</b>
+ preceeds <a href="#ChannelId">ChannelId</a> <b>Y</b> within the scope of an <a href="#ActionBinding">ActionBinding</a>, then the
+ Party prefers use of <b>X</b> over <b>Y</b> for the specified action.
+ </p>
+ <p>In a <a href="#CPA">CPA</a>, exactly one <a href="#ChannelId">ChannelId</a> MUST be present
+ in an <a href="#ActionBinding">ActionBinding</a>.
+ It identifies the channel that
+ Party and CounterParty agree to bind the specified action to.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Message Channels -->
+
+ <xs:element name="Channel" type="cppa:ChannelType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A CPPA3 <a href="#Channel">Channel</a>
+ configures the use of a messaging protocol for the exchange of user messages
+ and/or signal messages. A channel can be bound to particular business actions in service
+ collaborations between parties.
+ A channel MAY be a point-to-point channel or end-to-end,
+ for messaging protocols that support the concept, like ebMS3 using the multihop
+ advanced feature [EBMS3PART2].
+ This element is an abstract element. It is substituted by elements representing
+ specific messaging protocols defined in this schema or in extensions of this schema.
+ </p>
+ <p>A channel MAY relate to other channels. For example, the channel for ebMS3 user
+ messages MAY specify the use of another channel for the exchange of errors related to
+ that user message.
+ </p>
+ <p>A channel MAY be associated with a particular transport using
+ the <em>transport</em> attribute.</p>
+ <p>A channel MAY set the <em>asResponse</em> attribute to categorize a channel
+ as a forward channel or as a backchannel.
+ A forward channel is initiated by the sender.
+ A backchannel is a channel that is associated with some other channel that may not
+ be initiated by the sender and that allows communication in the reverse direction.
+
+ The following list describes some common situations:</p>
+ <ol>
+ <li>The <em>transport</em> attribute is present and the <em>asResponse</em>
+ attribute is either absent or present with a false value.
+ This expresses that the exchange uses the specified transport.
+ </li>
+ <li>The <em>transport</em> attribute is absent and the <em>asResponse</em> attribute
+ is present with a true value.
+ This expresses that the exchange uses a backchannel of some other channel.
+ Examples are synchronous responses or exchanges
+ that use a channel created by a polling mechanism.
+ </li>
+ </ol>
+ <p>The <em>transport</em> and <em>asResponse</em> attributes
+ are both absent in situations such as:</p>
+ <ul>
+ <li>End-to-end channels that consist of multiple hops across a chain of
+ store-and-forward messaging intermediaries. The transport differs for
+ each hop and therefore cannot be expressed for the end-to-end channel.</li>
+ <li>Situations where the transport is computed dynamically.</li>
+ </ul>
+ <p>These situations are described more precisely in the documentation of
+ non-abstract substitution elements.</p>
+ <p>Compared to CPPA2, in which the corresponding element was called <em>DeliveryChannel</em>,
+ the CPPA3 <a href="#Channel">Channel</a> element combines the Sender
+ and Receiver Protocol Bindings, which
+ in CPPA2 were contained in the <em>DocumentExchange</em> element.
+ As this element has no other
+ children, CPPA3 uses the substitutions for Protocol Binding directly to simplify and
+ flatten the structure of the <a href="#CPP">CPP</a> and
+ <a href="#CPA">CPA</a> elements.
+ The <a href="#Transport">Transport</a> is referenced from
+ the <a href="#Channel">Channel</a> directly.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ChannelType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This is an abstract type covering channel bindings to message protocols. </p>
+ <p>The <a href="#MaxSize">MaxSize</a> Specifies the maximum size of the payloads
+ of message using a particular protocol binding. </p>
+ <p>When used with ebMS3, the <a href="#MaxSize">MaxSize</a> element maps to
+ <em>PMode[1].BusinessInfo.PayloadProfile.maxSize</em>.
+ In CPPA3 it is specified at <a href="#Channel">Channel</a> level rather
+ than at <a href="#PayloadProfile">PayloadProfile</a>
+ level, because the size limits can be protocol-specific.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:ChannelProfile" minOccurs="0"/>
+ <xs:element ref="cppa:MaxSize" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required">
+ <xs:annotation>
+ <xs:documentation>A unique identifier for the <a href="#Channel">Channel</a> for cross-referencing
+ within the XML document.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="transport" type="xs:IDREF" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>transport</em> attribute references a <a href="#Transport">Transport</a>
+ to be used
+ by the <a href="#Channel">Channel</a>.
+ This attribute MUST NOT be present if <em>asResponse</em> is set
+ to <em>false</em>. Otherwise,
+ requirements for presence or absence of this attribute depend on
+ specific channel bindings. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="asResponse" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Specifies if the channel is to use the backchannel of an underlying transport
+ set up by another channel. This feature is specified further for
+ subtypes of the channel element.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="package" type="xs:IDREF" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>package</em> attribute references a <em>Package</em> for
+ a <a href="#Channel">Channel</a>.</p>
+ <p>This attribute MUST NOT be used for channels used for protocol message types
+ that have a fixed and predictable format, such as receipts and erors.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:element name="ChannelExtension" abstract="true" type="cppa:ChannelExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract Channel Extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ChannelExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract Channel Extension type</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+
+ <xs:element name="ChannelProfile" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element identifies a particular profile of the messaging protocol.
+ For example, the AS4 ebHandler Conformance Profile of ebMS3 is identified
+ using the URI
+ <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/cprofiles/200809/as4ebhandler</em>.</p>
+ <p>In some communities using ebMS3, different profiles are used and selected using the
+ <em>AgreementRef</em> header field and <em>PMode.Agreement</em> parameter. A potential use
+ of <a href="#ChannelProfile">ChannelProfile</a> is to set this value.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Channel Feature -->
+
+ <xs:element name="ChannelFeature" abstract="true" type="cppa:ChannelFeatureType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#ChannelFeature">ChannelFeature</a> element defines a
+ reusable specification of a
+ feature or aspect of a channel. It
+ is to be instantiated to specific features such as security or reliable messaging.
+ Channel features MAY be specific to specific types of
+ <a href="#Channel">Channel</a>s.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ChannelFeatureType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This is an abstract type covering channel features. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:attribute name="id" type="xs:ID">
+ <xs:annotation>
+ <xs:documentation>Identifier of the channel feature. This allows the feature to be reused
+ in multiple channels. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <!-- Named Channel Binding -->
+
+ <xs:element name="NamedChannel" substitutionGroup="cppa:Channel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The Named Channel provides a Channel identified using a Named Channel and supplies any named
+ Parameters.
+ Specific named channels MAY associate with or require specific parameters. The CPPA3 schema does not
+ constrain specific parameters and/or values. The Named Channel option assumes parties infer the
+ protocol to be used and all or most configuration parameters for that protocol from a specified and
+ mutually understood name. The type definition includes Signing and Encryption certification references,
+ which are inherently partner specific. Other parameters can be specified using
+ <a href="#Param">Param</a> elements.
+ <a href="#NamedChannel">NamedChannel</a>s MAY be interpreted (and hence used) in one of two ways:
+ </p>
+ <ol>
+ <li>As a <em>macro</em> facility, to simplify the management of CPPs and CPAs that have
+ many largely identical protocol bindings. The named binding MAY be mapped to a a more complete
+ binding that defines additional configurations.
+ The semantics of the element is defined in terms of the semantics of that binding. </li>
+ <li>To identify a particular configuration of some protocol that can be
+ mapped to particular configurations in CPPA3 aware software. This can even be used for
+ protocols for which the CPPA3 schema does not specify bindings.
+ </li>
+ </ol>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence>
+ <xs:element ref="cppa:ChannelName"/>
+ <xs:element ref="cppa:SigningCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:SigningCertificateRequired" minOccurs="0"/>
+ <xs:element ref="cppa:SigningTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificateRequired" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:Param" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:NamedChannelExtension" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ChannelName" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The name of the channel used in the NamedChannel.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Param">
+ <xs:complexType>
+ <xs:annotation>
+ <xs:documentation>A parameter name/value pair.</xs:documentation>
+ </xs:annotation>
+ <!--
+ <xs:sequence>
+ <xs:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="unbounded"
+ />
+ </xs:sequence>
+ -->
+ <xs:attribute name="name" type="cppa:non-empty-string" use="required">
+ <xs:annotation>
+ <xs:documentation>The name of the parameter.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="NamedChannelExtension" abstract="true" type="cppa:NamedChannelExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract NamedChannel extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="NamedChannelExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract NamedChannel extension type</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelExtensionType"> </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+
+ <!-- EDIINT -->
+
+ <xs:element name="EDIINTChannel" type="cppa:EDIINTChannelType" substitutionGroup="cppa:Channel"
+ abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines an abstract EDIINT message channel. The element definition generalizes over the
+ three EDIINT Application Statements for SMTP (AS1), HTTP (AS2) and FTP (AS3) [RFC3335, RFC4130,
+ RFC4823].
+ Whether an EDIINT message is to be sent using AS1, AS2 or AS3 is selected by the
+ choice of an <a href="#AS1Channel">AS1Channel</a>, <a href="#AS2Channel">AS2Channel</a> or
+ <a href="#AS3Channel">AS3Channel</a> element. This choice instructs the messaging
+ application using the CPPA3 document to apply the applicable Applicability Statement.
+ </p>
+ <p>The <a href="#Signature">Signature</a> element indicates that the EDIINT data is wrapped in a
+ <em>multipart/signed</em> MIME structure. </p>
+ <p>The <a href="#Encryption">Encryption</a> element indicates that the EDIINT data is wrapped in a
+ <em>multipart/encrypted</em> MIME structure. </p>
+
+ <p>For EDIINT, the <a href="#ReceiptHandling">ReceiptHandling</a> element configures the
+ processing of EDIINT Message Disposition
+ Notifications (MDNs). The configuration of receipt processing with EDIINT is specified in the
+ documentation of the <a href="#ReceiptHandling">ReceiptHandling</a> element.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="EDIINTChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This channel type definition generalizes over configurations of channels using
+ EDIINT AS1, AS2 and AS3 [RFC3335, RFC4130, RFC4823].</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence>
+ <xs:element ref="cppa:Signature" minOccurs="0"/>
+ <xs:element ref="cppa:Encryption" minOccurs="0"/>
+ <xs:element ref="cppa:ErrorHandling" minOccurs="0"/>
+ <xs:element ref="cppa:ReceiptHandling" minOccurs="0"/>
+ <xs:element ref="cppa:Compression" minOccurs="0"/>
+ <xs:element ref="cppa:EDIINTChannelExtension" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="version" type="cppa:non-empty-string" default="1.0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>For AS2 or AS3, the version of the protocol used.
+ Version number 1.1 indicates support for the [RFC5402] compression feature.
+ Version number 1.2 indicates support for the [RFC6017] features feature.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="errorHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ErrorHandling">ErrorHandling</a> element.
+ If this attribute is present, there MUST NOT be a
+ child <a href="#ErrorHandling">ErrorHandling</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="receiptHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ReceiptHandling">ReceiptHandling</a> element.
+ If this attribute is present, there MUST NOT be a
+ child <a href="#ReceiptHandling">ReceiptHandling</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="EDIINTChannelExtension" abstract="true" type="cppa:EDIINTChannelExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract EDIINTChannel extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="EDIINTChannelExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract EDIINTChannel extension type</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelExtensionType"> </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+ <xs:element name="AS1Channel" type="cppa:EDIINTChannelType"
+ substitutionGroup="cppa:EDIINTChannel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures a channel using EDIINT AS1 [RFC3335].</p>
+ <p>As with any <em>EDIINT</em> channel, <a href="#ReceiptHandling">ReceiptHandling</a>
+ configures the processing of
+ Message Disposition Notifications.
+ </p>
+ <p>An <a href="#AS1Channel">AS1Channel</a> MUST be bound to an <a href="#SMTPTransport">SMTPTransport</a> transport.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="AS2Channel" type="cppa:EDIINTChannelType"
+ substitutionGroup="cppa:EDIINTChannel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures a channel using EDIINT AS2 [RFC4130].</p>
+ <p>When using an AS2 channel, the <em>AS2-From</em> and <em>AS2-To</em>
+ headers MUST be set to a Party/CounterParty
+ <a href="#PartyId">PartyId</a> element content.
+ </p>
+ <p>An <a href="#AS2Channel">AS2Channel</a> carrying business data MUST be
+ bound to an <a href="#HTTPTransport">HTTPTransport</a> transport.</p>
+ <p>An <a href="#AS2Channel">AS2Channel</a> carrying an MDN MUST</p>
+ <ul>
+ <li>If bound to a transport, the transport SHOULD be an <a href="#HTTPTransport">HTTPTransport</a> transport. </li>
+ <li>If not bound to a transport, the <em>asResponse</em> attribute MUST be
+ present with value <em>true</em>.</li>
+ </ul>
+ <p>As with any <em>EDIINT</em> channel, <a href="#ReceiptHandling">ReceiptHandling</a> configures the processing of
+ Message Disposition Notifications.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="AS3Channel" type="cppa:EDIINTChannelType"
+ substitutionGroup="cppa:EDIINTChannel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures a channel using EDIINT AS3 [RFC4823].</p>
+ <p>When using an AS3 channel, the <em>AS3-From</em> and <em>AS3-To</em>
+ headers MUST be set to a Party/CounterParty
+ <a href="#PartyId">PartyId</a> element content.
+ </p>
+ <p>An <a href="#AS3Channel">AS3Channel</a> MUST be bound to an <a href="#FTPTransport">FTPTransport</a> transport.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Web Services -->
+
+ <xs:element name="WSChannel" type="cppa:WSChannelType" substitutionGroup="cppa:Channel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures a channel using Web Services.
+ A Web Service Channel is a channel that uses SOAP 1.1 or SOAP 1.2 messaging. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="WSChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A type definition of a Web Services channel.</p>
+ <p>If multiple security binding elements are present, these MUST target
+ different SOAP actors or roles.</p>
+ <p>SOAPVersion is optional in situations where a <a href="#ChannelProfile">ChannelProfile</a> is specified that
+ fixes the version to use. This is the case, for example, in AS4 conformance profiles.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence>
+ <xs:element ref="cppa:SOAPVersion" minOccurs="0"/>
+ <xs:element ref="cppa:FaultHandling" minOccurs="0"/>
+ <xs:element ref="cppa:Addressing" minOccurs="0"/>
+ <xs:element ref="cppa:WSSecurityBinding" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ReliableMessagingBinding" minOccurs="0"/>
+ <xs:element ref="cppa:WSChannelExtension" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="securityBinding" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#WSSecurityBinding">WSSecurityBinding</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#WSSecurityBinding">WSSecurityBinding</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="reliableMessagingBinding" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ReliableMessagingBinding">ReliableMessagingBinding</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ReliableMessagingBinding">ReliableMessagingBinding</a>.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="addressing" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#Addressing">Addressing</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#Addressing">Addressing</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="WSChannelExtension" abstract="true" type="cppa:WSChannelExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract WSChannel extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="WSChannelExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract WSChannel extension type</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelExtensionType"> </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+
+
+ <xs:element name="SOAPVersion">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The version of SOAP to be used for messaging.</p>
+ <p>In ebMS3, this corresponds to the <em>PMode[].Protocol.SOAPVersion</em> parameter</p>
+ <p>If the element is not present in the containing <em>WSChannel</em> element
+ (or element that inherits from this element), it MUST
+ be specified indirectly, via the definition of a <a href="#ChannelProfile">ChannelProfile</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="1.1"/>
+ <xs:enumeration value="1.2"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+
+
+ <xs:element name="FaultHandling">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies the handling of faults.</p>
+ <p>Note that there are no PMode parameters defined in ebMS3 to configure fault handling.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element minOccurs="0" ref="cppa:FaultChannelId"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="FaultChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element is a cross-reference to the definition a of channel to be
+ used to exchange SOAP Faults.</p>
+ <p>If WS-Addressing is used, the <a href="#Endpoint">Endpoint</a> of the
+ referenced channel MUST be used for the <em>wsa:FaultTo</em> header.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Compression -->
+
+ <xs:element name="Compression" substitutionGroup="cppa:ChannelFeature"
+ type="cppa:CompressionType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element indicates that the message is compressed using message layer compression.
+ For EDIINT, when using encryption, the entire message is compressed.
+ For AS4, compression applies to the MIME parts in the SOAP-with-attachments envelope.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="CompressionType">
+ <xs:annotation>
+ <xs:documentation>The type of a <a href="#Compression">Compression</a> element.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element ref="cppa:CompressionAlgorithm" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:CompressionDictionary" minOccurs="0" maxOccurs="unbounded"/>
+
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="CompressionAlgorithm" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures the compression algorithm used. Its value identifies
+ the compression algorithm or compressed data format that the sending MSH applies to ebmessage. </p>
+ <ul>
+ <li>For the AS4 protocol, the only allowed value is <em>application/gzip</em>.</li>
+ <li>For the AS2 protocol, the only value is <em>application/pkcs7-mime</em> as
+ described in [RFC5402, RFC3851] which uses <em>ZLIB</em> compression [RFC1950].</li>
+ </ul>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="CompressionDictionary" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies, using a URI, a compression dictionary that parties can agree to use. This
+ element MUST NOT be used in combination with compression algorithms that do not support the use
+ of pre-agreed compression dictionaries.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- WS-Security -->
+
+
+
+ <xs:element name="WSSecurityBinding" type="cppa:WSSecurityBindingType"
+ substitutionGroup="cppa:ChannelFeature">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines the use of WS-Security.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="WSSecurityBindingType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>If the <em>SecurityPolicy</em> element is present or referenced,
+ it establishes the <em>default</em> security policy to
+ be used, which can be overridden using the <a href="#Signature">Signature</a>,
+ <a href="#Encryption">Encryption</a> or
+ <a href="#UserAuthentication">UserAuthentication</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element ref="cppa:WSSVersion" minOccurs="0"/>
+ <xs:element ref="cppa:SecurityPolicy" minOccurs="0"/>
+ <xs:element ref="cppa:SAMLToken" minOccurs="0"/>
+ <xs:element ref="cppa:Signature" minOccurs="0"/>
+ <xs:element ref="cppa:Encryption" minOccurs="0"/>
+ <xs:element ref="cppa:UserAuthentication" minOccurs="0"/>
+ <xs:any namespace="##other" processContents="lax" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="actorOrRole" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>The optional <em>actorOrRole</em> attribute identifies
+ the <em>actor</em> (SOAP 1.1) or <em>role</em> (SOAP 1.2) that the security header
+ targets. Specific values MAY be associated with specific processing.
+ For example, the value
+ <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/part2/200811/nextmsh</em>
+ indicates the use of the ebMS3 Part 2 multihop feature.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="securityPolicy" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a <em>SecurityPolicy</em> defined elsewhere in
+ the document. If present, there MUST NOT be a child <em>SecurityPolicy</em>
+ element.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="WSSVersion">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies the version of WS-Security to be used.
+ In ebMS3, this corresponds to the <em>PMode[1].Security.WSSVersion</em> parameter</p>
+ <p>The value <em>1.1</em> also covers the <em>1.1.1</em> version, as that version is
+ a maintenance update that does not provide additional or different functionality.</p>
+ <p>If the element is not present in the containing <a href="#WSSecurityBinding">WSSecurityBinding</a> element, it MUST
+ be specified indirectly, via the definition of a <a href="#ChannelProfile">ChannelProfile</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="1.0"/>
+ <xs:enumeration value="1.1"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+
+ <xs:element name="SecurityPolicy" substitutionGroup="cppa:ChannelFeature"
+ type="cppa:SecurityPolicyType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element can be used to associate a security policy with the message exchange.
+ The policy may be embedded in the CPPA3 document, or it may be referenced.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SecurityPolicyType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:any minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="href" type="xs:anyURI" use="required">
+ <xs:annotation>
+ <xs:documentation>If the <em>href</em> attribute is present it MUST reference a
+ WS-SecurityPolicy document stored outside the <a href="#CPP">CPP</a>
+ or <a href="#CPA">CPA</a> and the element
+ content MUST be empty.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <!-- Token References -->
+
+ <xs:simpleType name="WSSSecurityTokenReferenceType">
+ <xs:annotation>
+ <xs:documentation>The WS-Security X.509 Token Profile distinguishes three type of mechanisms to
+ reference security token. This type definition provides identifiers for these three values.
+ XML Signature 1.1 deprecates <em>X509IssuerSerial</em> and suggests that instead
+ <em>X509Digest</em> be used. This value is provided for potential future use.
+ </xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="SubjectKeyIdentifier"/>
+ <xs:enumeration value="BinarySecurityToken"/>
+ <xs:enumeration value="X509IssuerSerial"/>
+ <xs:enumeration value="X509Digest"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+ <!-- Signature-->
+
+ <xs:element name="Signature">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Signature">Signature</a> element configures message signing.
+ The CPPA3 <a href="#Signature">Signature</a> element is modelled after
+ the W3C XML Signature structure [XMLDSIG-CORE, XMLDSIG-CORE1] but is also
+ used to configure EDIINT.
+ </p>
+ <p>In ebMS3, this type corresponds to the <em>PMode[1].Security.X509.*</em> parameters. </p>
+ <p>In a <a href="#CPP">CPP</a>, <a href="#SignatureAlgorithm">SignatureAlgorithm</a>,
+ <a href="#DigestAlgorithm">DigestAlgorithm</a> and
+ <a href="#CanonicalizationMethod">CanonicalizationMethod</a> MAY occur more than once,
+ expressing alternative options.
+ In a <a href="#CPA">CPA</a>, they MUST occur at most once, expressing the agreed option.
+ </p>
+ <p>For EDIINT protocols, the <em>SignElements</em>, <em>SignAttachments</em>,
+ <em>SignExternalPayloads</em> and <em>SAMLTokenRef</em> elements MUST NOT be used.</p>
+ <p>If the <a href="#SignatureAlgorithm">SignatureAlgorithm</a> and
+ <a href="#DigestAlgorithm">DigestAlgorithm</a> elements are not present, they MUST
+ be specified indirectly, via the definition of a <a href="#ChannelProfile">ChannelProfile</a>.
+ </p>
+ <p>If one or more <a href="#SigningCertificatePolicySetRef">SigningCertificatePolicySetRef</a> elements
+ is present, Policy Certification Authority certificates and the issuing Certificate Authority
+ certificate in the signing certificate chain MUST contain a <em>certificatePolicies</em>
+ X.509 extension, the values of which MUST be within the set of referenced policies.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:SignatureFormat" minOccurs="0"/>
+ <xs:element ref="cppa:SignatureAlgorithm" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:DigestAlgorithm" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:CanonicalizationMethod" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:SignatureTransformation" minOccurs="0"/>
+ <xs:element ref="cppa:SigningCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:SigningCertificateRequired" minOccurs="0"/>
+ <xs:element ref="cppa:SigningTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:SigningCertificatePolicySetRef" minOccurs="0"
+ maxOccurs="unbounded"/>
+ <xs:element ref="cppa:SigningCertificateRefType" minOccurs="0" maxOccurs="4"/>
+ <xs:element ref="cppa:SAMLTokenRef" minOccurs="0"/>
+ <xs:element ref="cppa:SignElements" minOccurs="0"/>
+ <xs:element ref="cppa:SignAttachments" minOccurs="0"/>
+ <xs:element ref="cppa:SignExternalPayloads" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SignatureFormat">
+ <xs:annotation>
+ <xs:documentation>
+ <xs:documentation>
+ <p>This element identifiers a format to be used for signatures. It MUST NOT be used in
+ contexts where only a single signature format is used, or where it is not possible
+ to select a
+ specific format, or where it is not common to specify the format.</p>
+ <p>For EDIINT, a common value is <em>pkcs7-signature</em>.</p>
+ </xs:documentation>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute name="version" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The version number of the signature format. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+
+ </xs:element>
+
+ <xs:element name="SignatureAlgorithm" type="cppa:AlgorithmType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines the signature algorithm to be used for generating and validating the
+ signature. </p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Signature.Algorithm</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="DigestAlgorithm" type="cppa:AlgorithmType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>DigestAlgorithm is a REQUIRED element that identifies the digest algorithm to be
+ applied to the signed object.</p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Signature.HashFunction</em> parameter.
+ </p>
+ <p>AS2 (RFC 4130) can use the values MD5 (defined in [RFC6931] as
+ <em>http://www.w3.org/2001/04/xmldsig-more#md5</em>) or SHA-1 (defined in
+ [XMLDSIG-CORE] as <em>http://www.w3.org/2000/09/xmldsig#sha1</em>.
+ AS2 implementations also implement more recent algorithms.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="CanonicalizationMethod" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The Canonicalization method to be applied in the creation of the signature.</p>
+ <p>This element does not correspond to any ebMS3 PMode parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SignatureTransformation" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The Signature Transformation method to be applied in the creation of the signature.</p>
+ <p>This element does not correspond to any ebMS3 PMode parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SigningCertificateRef" type="cppa:CertificateRefType"
+ substitutionGroup="cppa:CertificateRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to the leaf certificate that is to be used to sign the data.</p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Signature.Certificate</em> parameter.</p>
+ <p>Requirements on presence or absence of this element in a CPP or CPA and use in CPA formation
+ can be configured using
+ the <a href="#SigningCertificateRequired">SigningCertificateRequired</a> element.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SigningCertificateRequired" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>In a CPP, this element can be used in a <a href="#NamedChannel">NamedChannel</a> or <a href="#Signature">Signature</a> element by a receiving party to indicate whether a leaf
+ signing certificate is to be provided by the sending (i.e. signing) party in the
+ corresponding element in its CPP. If present with a true value in a CPP context for a
+ receiver channel, a valid <a href="#SigningCertificateRef">SigningCertificateRef</a> element
+ MUST be present in the CPP of the sending party for the channel. This referenced
+ certificate MUST be included for specified signed CPA channel in a CPA derived from these
+ CPPs for the channel.
+ </p>
+ <p>This element MUST NOT be used in a CPA. If specified in a CPP for the
+ sending (signing) party for the channel, its value is ignored in unification.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SigningCertificateRefType" type="cppa:WSSSecurityTokenReferenceType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Specifies how the signing certificate is referenced in the WS-Security header</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <xs:element name="SignElements">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This elements specifies, as a sequence of <a href="#Expression">Expression</a> elements, the elements in the message that
+ MUST be signed. </p>
+ <p>This element MUST NOT be present in a <em>SignatureType</em> content that is not SOAP or another
+ XML-based message format. Furthermore, it MUST NOT be present in protocols or profiles that do
+ not support configuration of elements that are to be signed. This is the case with AS4, which always
+ signs a known set of SOAP parts, if the message is signed.
+ </p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Sign.Element</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Expression" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SignAttachments" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This Boolean-valued element specifies if attachments are to be signed.</p>
+ <p>This element MUST NOT be present in message formats that do not support attachments or
+ signing of attachments. Furthermore, it MUST NOT be present in protocols or profiles that do not
+ support configuration of attachment signing. This is the case with AS4, which always signs all
+ attachments if the message is signed.
+ </p>
+ <p>In ebMS3, this corresponds to the <em>PMode[1].Security.X509.Sign.Attachment</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SignExternalPayloads" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies if external payloads are to be signed.</p>
+ <p>This element MUST NOT be present in message formats that do not support external payloads or
+ signing of external payloads.
+ </p>
+ <p>There is no corresponding ebMS3 PMode parameter for this element.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SigningTrustAnchorSetRef" type="cppa:CertificateRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a trust anchor that a signing certificate MUST chain to.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SigningCertificatePolicySetRef" type="cppa:CertificatePolicySetReferenceType">
+ <xs:annotation>
+ <xs:documentation>A reference to an X.509 certificate policy set to be used for a
+ signing certificate.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Encryption">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Encryption">Encryption</a> element configures message encryption.
+ The CPPA3 <a href="#Encryption">Encryption</a> element is modelled after the
+ W3C XML Encryption [XMLENC-CORE, XMLENC-CORE1] structure but is also
+ used to configure encryption for channels that do not use XML Encryption.
+ </p>
+ <p>In ebMS3, this structure corresponds to the <em>PMode[1].Security.X509.Encryption.*</em> parameters.</p>
+ <p>If one or more <a href="#EncryptionCertificatePolicySetRef">EncryptionCertificatePolicySetRef</a> elements
+ is present, Policy Certification Authority certificates and the issuing Certificate Authority
+ certificate in the encryption certificate chain MUST contain a <em>certificatePolicies</em>
+ X.509 extension, the values of which MUST be within the set of referenced policies.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:annotation>
+ <xs:documentation>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:EncryptionFormat" minOccurs="0"/>
+ <xs:element ref="cppa:KeyEncryption" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionAlgorithm" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:EncryptElements" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptAttachments" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptExternalPayloads" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificateRequired" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:EncryptionCertificatePolicySetRef" minOccurs="0"
+ maxOccurs="unbounded"/>
+ <xs:element ref="cppa:EncryptionCertificateRefType" minOccurs="0" maxOccurs="4"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="KeyEncryption">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>KeyTransport</em> element supports the configuration of encryption key transport.
+ It is designed to configure use of
+ <a href="http://www.w3.org/TR/2013/REC-xmlenc-core1-20130411/#sec-Alg-KeyTransport">XML
+ Encryption Key Transport</a> and similar protocols.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:EncryptionAlgorithm" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:MaskGenerationFunction" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:DigestAlgorithm" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+
+ </xs:element>
+
+ <xs:element name="MaskGenerationFunction" type="cppa:AlgorithmType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies the use of a mask generation function.</p>
+ <p>The value is an identifier of a mask generation function like
+ <a href="http://www.w3.org/2009/xmlenc11#mgf1sha256">http://www.w3.org/2009/xmlenc11#mgf1sha256</a>.</p>
+ <p>When using XML encryption, it specifies the value of
+ <em>xenc:EncryptedKey / xenc:EncryptionMethod / xenc11:MGF</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptionFormat">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element MUST NOT be used with protocols that have a fixed data format for
+ encrypted content, such as WS-Security. </p>
+ <p>This element corresponds to the CPPA2 <em>DigitalEnvelope</em> element. When used
+ with ebMS2, it can be used to select the digital envelope format to be used
+ with the use of that protocol.
+ The use of S/MIME is selected the value <em>S/MIME</em>.
+ For S/MIME, the current version in 3.2, defined in [RFC5751]. Other versions MAY be
+ selected using the <em>version</em> attribute.
+ XML Encryption is selected used the value <em>http://www.w3.org/2001/04/xmlenc#</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute name="version" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The version number of the encryption format. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="EncryptionAlgorithm" type="cppa:AlgorithmType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element can be used to specify the key transport algorithm and the data encryption
+ algorithm.</p>
+ <p>Key Transport algorithms are public key encryption algorithms especially specified
+ for encrypting and decrypting keys.
+ When using XML Encryption the value of this element can be used as value in <em>KeyEncryption</em>
+ to determine
+ <em>xenc:EncryptedKey / xenc:EncryptionMethod / @Algorithm</em>. The
+ value is an identifier of an encryption algorithm
+ like <a href="http://www.w3.org/2009/xmlenc11#rsa-oaep">http://www.w3.org/2009/xmlenc11#rsa-oaep</a>.
+ </p>
+ <p>In ebMS3, see <a href="https://issues.oasis-open.org/browse/EBXMLMSG-45">https://issues.oasis-open.org/browse/EBXMLMSG-45</a>.</p>
+
+ <p>
+ When using XML Encryption, the <a href="#EncryptionAlgorithm">EncryptionAlgorithm</a> element
+ can also be used
+ in <a href="#DataEncryption">DataEncryption</a> to set the value
+ of the <em>xenc:EncryptedData / xenc:EncryptionMethod / @Algorithm</em> attribute.
+ The value is an identifier like <a href="http://www.w3.org/2009/xmlenc11#aes128-gcm">http://www.w3.org/2009/xmlenc11#aes128-gcm</a>
+ </p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Encryption.Algorithm</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptElements">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element expresses elements that MUST be encrypted.</p>
+ <p>This element MUST NOT be present in a <a href="#DataEncryption">DataEncryption</a>
+ element that is not SOAP or another
+ XML-based message format. Furthermore, it MUST NOT be present in protocols or profiles that do
+ not support configuration of elements that are to be signed. This is the case with AS4, which always
+ signs a known set of SOAP parts if the message is signed.
+ </p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Encrypt.Element</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Expression" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="EncryptAttachments" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element expresses whether or not attachments are encrypted.</p>
+ <p>This element MUST NOT be present in message formats that do not support
+ attachments or encryption of attachments.
+ Furthermore, it MUST NOT be present in protocols or profiles that do not support
+ configuration of attachment
+ encryption. This is the case with AS4, which always signs all attachments if
+ the message is signed.
+ </p>
+ <p>In ebMS3, this corresponds to the
+ <em>PMode[1].Security.X509.Encrypt.Attachment</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptExternalPayloads" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element expresses whether or not external payloads are encrypted.</p>
+ <p>This element MUST NOT be present in message formats that do not support
+ external payloads or encryption of attachments.
+ Furthermore, it MUST NOT be present in protocols or profiles that do not support
+ configuration of external payload encryption. This is the case with AS4,
+ which always encrypts all attachments if the message is signed.
+ </p>
+ <p>There is no corresponding PMode parameter for this element.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="AlgorithmType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>For signing and encryption algorithms, the value of an element of type <em>AlgorithmType</em>
+ MUST be an algorithm identifier defined in XML Signature [XMLDSIGCORE, XMLDSIGCORE1],
+ XML Encryption [XMLENC-CORE, XMLENC-CORE1] or in RFC 6931.
+ </p>
+ <p>Note that these algorithm identifier URIs specify the key size, e.g.
+ <em>http://www.w3.org/2009/xmlenc11#aes128-gcm</em> and
+ <em>http://www.w3.org/2009/xmlenc11#aes256-gcm</em> specify 128 and 256 bit sizes, respectively.
+ Therefore this element also covers the CPPA2 <em>minimumStrength</em> attribute and the ebMS3
+ <em>PMode[1].Security.X509.Encryption.MinimumStrength</em> P-Mode parameter.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleContent>
+ <xs:extension base="xs:anyURI">
+ <xs:attribute name="version" use="optional">
+ <xs:annotation>
+ <xs:documentation>An optional version indicator of the algorithm</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+
+
+ <xs:element name="EncryptionCertificateRef" type="cppa:CertificateRefType"
+ substitutionGroup="cppa:CertificateRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element references a leaf certificate that is to be used for encryption.</p>
+ <p>With ebMS3, this element corresponds with the
+ <em>PMode[1].Security.X509.Encryption.Certificate</em> parameter.</p>
+ <p>Requirements on presence or absence of this element in a CPP or CPA and use in CPA formation
+ can be configured using
+ the <a href="#EncryptionCertificateRequired">EncryptionCertificateRequired</a> element.
+ </p>
+
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptionCertificateRequired" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>In a CPP, this element can be used in a <a href="#NamedChannel">NamedChannel</a> or <a href="#Encryption">Encryption</a> element by a sending party to indicate whether a leaf
+ encryption certificate is to be provided by the receiving (i.e. decrypting) party in the
+ corresponding element in its CPP. If present with a true value in a CPP context for a
+ receiver channel, or if the element is absent,
+ a valid <a href="#EncryptionCertificateRef">EncryptionCertificateRef</a> element
+ MUST be present in the CPP of the receiving party for the channel. This referenced
+ certificate MUST be included for specified encrypted CPA channel in a CPA derived
+ from these CPPs for the channel.
+ </p>
+ <p>This element MUST NOT be used in a CPA. If specified in a CPP for the
+ receiving (decrypting) party for the channel, its value is ignored in unification.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptionCertificateRefType" type="cppa:WSSSecurityTokenReferenceType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies how the encryption certificate is referenced in the WS-Security header</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptionTrustAnchorSetRef" type="cppa:CertificateRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a trust anchor set that an encryption certificate MUST chain to.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="EncryptionCertificatePolicySetRef"
+ type="cppa:CertificatePolicySetReferenceType">
+ <xs:annotation>
+ <xs:documentation>A reference to an X.509 certificate policy set to be used for an
+ encryption certificate.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <!-- Security Assertion Markup Language (SAML) -->
+
+ <xs:element name="SAMLToken" abstract="true" type="cppa:SAMLTokenType"
+ substitutionGroup="cppa:SecurityToken">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element is an abstract Security Assertion Markup Language (SAML)
+ configuration element that controls the presence and processing
+ of a SAML token in the WS-Security header.
+ Details on use of SAML are to be provided by substitution elements.
+ Support for the Security Assertion Markup Language (SAML) is in this version of
+ CPPA limited to providing support for the ebMS3 SAML conformance clause
+ [ebMS-saml-conformance].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SAMLTokenType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract SAML Token Type.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenType"/>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="SAMLTokenRef" substitutionGroup="cppa:SecurityTokenRef"
+ type="cppa:SAMLTokenRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a SAML token.</p>
+ </xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <xs:complexType name="SAMLTokenRefType">
+ <xs:complexContent>
+ <xs:extension base="cppa:SecurityTokenRefType">
+ <xs:attribute name="tokenId" type="xs:IDREF" use="required">
+ <xs:annotation>
+ <xs:documentation>A IDREF type reference to a SAML token</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="SAMLKeyConfirmedSubjectToken" substitutionGroup="cppa:SAMLToken">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used with ebMS3, this element defines support for the ebMS3 SAML conformance
+ clause [ebMS-saml-conformance], which provides ebMS3 with an alternative way of obtaining and
+ referencing a signing key. The SAML conformance clause is based on use of
+ signed holder-of-key subject
+ confirmations using either symmetric or asymmetric keys and to obtain attributes.
+ The ebMS3 SAML
+ conformance clause is designed to obviate the need for agreements such as <a href="#CPA">CPA</a>
+ and of <a href="#CPA">CPA</a> formation. Parties MAY use
+ partner <a href="#CPP">CPP</a> s directly to dynamically
+ configure ebMS3 messaging.
+ This element and its sub-elements correspond to
+ the a superset of <em>PMode[1].Security.SAML</em> parameters defined in
+ the ebMS3 SAML Conformance clause.
+ </p>
+ <p>The mandatory <a href="#IDPRegistrationSetRef">IDPRegistrationSetRef</a> element
+ references a set of identity
+ service providers that the party MUST register with. It corresponds to the
+ <em>PMode[1].Security.SAML.RegisteredIdPs</em> parameter and can be used in both
+ CPPs and CPAs.
+ </p>
+ <p>In <a href="#CPA">CPA</a> formation, it MUST be verified that the intersection of IDP sets of
+ Sender and Receiver is non-empty, as both Sender and Receiver MUST register
+ with the same IDP. This IDP authenticates Sender and (if symmetric proof keys
+ are used) encrypts the proof key for Receiver. The first matching shared IDP
+ MAY be referenced in the formed <a href="#CPA">CPA</a> using the <a href="#ProviderID">ProviderID</a> element.
+ However, this is only a hint as the Sender MAY use any shared IDP acceptable to
+ Receiver. The <a href="#ProviderID">ProviderID</a> element MUST NOT be used
+ in a <a href="#CPP">CPP</a>.
+ </p>
+ <p>Optionally, Sender MAY reference a particular signing certificate for
+ use as asymmetric proof key using the <a href="#SigningCertificateRef">SigningCertificateRef</a> element.
+ This reference MAY be used by Sender to select the
+ assymmetric key to include in the WS-Trust (or equivalent) request to the secure
+ token service. Note that the purpose of the SAML conformance clause
+ is to obviate the need for certificate exchange, so Receiver is NOT REQUIRED
+ to validate this on incoming messages.
+ This is a feature in CPPA3 that does not correspond
+ to a parameter in the ebMS3 SAML conformance clause P-Mode.
+ The <a href="#SigningCertificateRef">SigningCertificateRef</a> element
+ MUST NOT be present when symmetric proof
+ keys are used.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:SAMLTokenType">
+ <xs:sequence>
+ <xs:element ref="cppa:SAMLVersion"/>
+ <xs:element ref="cppa:IDPRegistrationSetRef"/>
+ <xs:element ref="cppa:ProviderID" minOccurs="0"/>
+ <xs:element ref="cppa:SigningCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:SAMLAttribute" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:KeyType"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SAMLVersion">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies the version of SAML that MUST be used for SAML Authentication.</p>
+ <p>In the ebMS3 SAML Conformance Clause, this corresponds to the
+ <em>PMode[].Security.SAML.Version</em> parameter.</p>
+ <p>The values correspond to
+ <em>/sp:SamlToken/wsp:Policy/sp:WssSamlV11Token11</em>
+ and <em>/sp:SamlToken/wsp:Policy/sp:WssSamlV20Token</em>
+ in WS-SecurityPolicy [WSSecurityPolicy13].</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="1.1"/>
+ <xs:enumeration value="2.0"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+
+ <xs:element name="KeyType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element specifies the type of the SAML proof key. The ebMS3 SAML Conformance Clause
+ supports symmetric and asymmetric key types. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="symmetric"/>
+ <xs:enumeration value="asymmetric"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+
+ <xs:element name="SAMLAttribute" type="cppa:SAMLAttributeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies the use of a SAML Attribute assertion in a SAML token.</p>
+ <p>This element, which can occur multiple times in the <em>SAMLKeyConfirmedSubject</em>
+ element, corresponds to the
+ <em>PMode[1].Security.SAML.MandatoryAttributes</em>
+ <em>PMode[1].Security.SAML.OptionalAttributes</em> parameters. Whether an
+ attribute is mandatory or optional is specified using the mandatory <em>use</em> attribute.
+ </p>
+ <p>When used in a WS-Security header used to secure an ebMS3 PullRequest and targeted to
+ the <em>ebms</em> role, occurrences of this element correspond to the
+ <em>PMode[1].Initiator.Authorization.SAML.AttributesAndValues</em> parameter.
+ In that case, the required values MUST be specified as content of the
+ <em>AttributeValue</em> child element.
+ </p>
+ <p>Apart from the <em>use</em> attribute, the definition of <em>SAMLAttribute</em>
+ copies the element and attribute content definitions of the SAML 2.0 Core schema.
+ </p>
+ <p>The set of mandatory attributes corresponds to <em>/sp:SamlToken/wst:Claims</em>
+ in WS-SecurityPolicy [WSSecurityPolicy13].</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:complexType name="SAMLAttributeType">
+ <xs:sequence>
+ <xs:element ref="cppa:AttributeValue" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="use" type="cppa:usetype" use="required">
+ <xs:annotation>
+ <xs:documentation>If <em>true</em>, the attribute is a
+ <em>PMode[1].Security.SAML.MandatoryAttributes</em> attribute.
+ If <em>false</em>, it is a <em>PMode[1].Security.SAML.OptionalAttributes</em>
+ attribute.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="Name" type="xs:string" use="required"/>
+ <xs:attribute name="NameFormat" type="xs:anyURI" use="optional"/>
+ <xs:attribute name="FriendlyName" type="xs:string" use="optional"/>
+ <xs:anyAttribute namespace="##other" processContents="lax"/>
+ </xs:complexType>
+
+ <xs:element name="AttributeValue" type="xs:anyType" nillable="true"/>
+
+ <!-- Username based authentication -->
+
+ <xs:element name="UserAuthentication" type="cppa:UserAuthenticationType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures user authentication. It can configure
+ UsernameToken security in WS-Security or HTTP Authentication.</p>
+ <p>When used with ebMS3 for WS-Security, this element covers the
+ <em>PMode[1].Security.UsernameToken.username</em>
+ <em>PMode[1].Security.UsernameToken.password</em>
+ <em>PMode[1].Security.UsernameToken.Digest</em>
+ <em>PMode[1].Security.UsernameToken.Nonce</em> and
+ <em>PMode[1].Security.UsernameToken.Created</em> parameters, when applied to the regular
+ WS-Security header.
+ </p>
+ <p>When used with ebMS3, this element also covers the combination of
+ <em>PMode[1].Security.PModeAuthorize</em>
+ and <em>PMode.{Initiator/Responder).Authorization.*</em> parameters that apply to the WS-Security
+ header that is used for message authorization.
+ </p>
+ <p>When used with the HTTP protocol, this element configures
+ HTTP Authentication.</p>
+ <p>The <em>Username</em> and <em>Password</em> elements MUST NOT be set in a <a href="#CPP">CPP</a> but
+ MUST be set in a <a href="#CPA">CPA</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="UserAuthenticationType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Type Definition for User Authentication.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:Username" minOccurs="0"/>
+ <xs:element ref="cppa:Password" minOccurs="0"/>
+ <xs:element ref="cppa:Digest" minOccurs="0"/>
+ <xs:element ref="cppa:Nonce" minOccurs="0"/>
+ <xs:element ref="cppa:Created" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+
+
+ <xs:element name="Username" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <em>Username</em> that MUST be used with <em>UserAuthentication</em>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Password" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <em>Password</em> that MUST be used with <em>UserAuthentication</em>.
+ In <a href="#CPA">CPA</a> formation, the
+ value of this element MUST be set to a sufficiently strong and unpredictable value.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Digest" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element expresses whether the <em>UserAuthentication</em> uses Digest Authentication.
+ The algorithm used for digest generation depends on the context in which
+ <em>UserAuthentication</em> is used. In HTTP, it is MD5 and in WS-Security,
+ it is SHA1.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Nonce" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element expresses whether a <em>Nonce</em> MUST or MUST NOT be included with
+ a <em>UserAuthentication</em>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Created" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Expresses whether a <em>Created</em> MUST or MUST NOT be included
+ with a <em>UserAuthentication</em>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Reliable Messaging -->
+
+ <xs:element name="ReliableMessagingBinding" type="cppa:ReliableMessagingBindingType"
+ abstract="true" substitutionGroup="cppa:ChannelFeature">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The abstract element <a href="#ReliableMessagingBinding">ReliableMessagingBinding</a> specifies a binding of a
+ channel to a reliable messaging protocol.
+ </p>
+ <p>This element is a channel feature, so its instances can be reused by reference in multiple
+ channel definitions. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ReliableMessagingBindingType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>
+ The <em>ReliableMessagingBindingType</em> type is defined as an abstract type
+ with no elements or attributes. It is an abstract type that can be specialized,
+ in extensions of this schema,
+ for reliable messaging protocols such as WS-ReliableMessaging and WS-Reliability.
+ This schema includes support for AS4, and then configures duplicate handling,
+ persistence and retransmission handling for AS4 messages.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element ref="cppa:DuplicateHandling" minOccurs="0"/>
+ <xs:element ref="cppa:RetryHandlingBase" minOccurs="0"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="DuplicateHandling">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>DuplicateHandling</em> element specifies a feature used by various reliable
+ messaging protocols. It specifies how received duplicates are to be
+ detected and/or processed.
+ </p>
+ <p>The type definition provides common parameters for duplicate handling.
+ The logic for determining whether a message is a duplicate depends on
+ the messaging protocol.
+ Any <em>##other</em> content may convey additional configuration parameters
+ for duplicate handling.
+ </p>
+ <p>When used with <em>WSReliableMessagingBinding</em>, this element corresponds to the
+ <em>PMode[1].Reliability.AtMostOnce.Contract</em> parameter.
+ </p>
+ <p>When used with AS4 reception awareness, this element corresponds to
+ <em>PMode[1].ReceptionAwareness.DuplicateDetection</em>
+ <em>PMode[1].ReceptionAwareness.DetectDuplicates.Parameters</em>
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:DuplicateElimination"/>
+ <xs:element ref="cppa:PersistDuration" minOccurs="0"/>
+ <xs:any namespace="##other" processContents="lax" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="DuplicateElimination" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>DuplicateElimination</em> element specifies if a receiving MSH MUST
+ eliminate any received duplicates, if detected, thus implementing <em>at most once</em>
+ delivery assurance.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="PersistDuration" type="xs:duration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The value of the PersistDuration element is the minimum length of time,
+ expressed as an XML
+ Schema duration, that data from a message that is sent reliably is kept in
+ Persistent Storage by message service implementation that receives that message to
+ facilitate the elimination of duplicates. </p>
+ </xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <xs:element name="RetryHandlingBase" abstract="true" type="cppa:RetryHandlingBaseType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>RetryHandlingBase</em> element specifies the handling of retransmission of
+ messages until successful processing of the message by the recipient
+ is confirmed, the number of retransmissions is exhausted or an unrecovereable
+ error occurs. This mechanism supports <em>at least once</em> delivery assurance.
+ This element is an abstract element, to support extensibility to other
+ features for handling retries.
+ </p>
+ <p>When used with AS4 reception awareness, this element corresponds to the
+ <em>PMode[1].ReceptionAwareness.Retry</em>
+ <em>PMode[1].ReceptionAwareness.Retry.Parameters</em>
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="RetryHandlingBaseType" abstract="true"/>
+
+ <xs:element name="RetryHandling" substitutionGroup="cppa:RetryHandlingBase">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines a basic set of configuration elements.</p>
+ <p>If <em>ExponentialBackoff</em> is present, the element <em>RetryInterval</em> MUST occur
+ at most once. </p>
+ <p>If <em>ExponentialBackoff</em> is not present, <em>retryvalue</em> is the
+ value of <em>Retries</em> element, and <em>retryintervalcount</em> is
+ the number of
+ occurrences of the element <em>RetryInterval</em>, then <em>retryintervalcount</em> MUST
+ NOT exceed <em>retryvalue</em>. If <em>retryintervalcount</em> is less than <em>retryvalue</em>,
+ this is equivalant to up to <em>retryvalue</em> additional <em>RetryInterval</em>
+ elements being present,
+ with the same value as the last specified value for <em>RetryInterval</em>.
+ </p>
+ <p>Any randomized adjustment of the timing of retransmissions (for example, to smooth out
+ congestions) is implementation-dependent and not explicitly configured.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:RetryHandlingBaseType">
+ <xs:sequence>
+ <xs:element ref="cppa:Retries"/>
+ <xs:element ref="cppa:ExponentialBackoff" minOccurs="0"/>
+ <xs:element ref="cppa:RetryInterval" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="Retries" type="xs:integer">
+ <xs:annotation>
+ <xs:documentation>The maximum number of retries.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="RetryInterval" type="xs:duration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The duration between a transmission attempt and the next one. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ExponentialBackoff">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Presence of this element specifies that the <em>RetryInterval</em> MUST be
+ adjusted according to the exponential backoff algorithm.</p>
+ <p>The value of <em>Ceiling</em> MUST be less than <em>Retries</em>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:annotation>
+ <xs:documentation>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:Ceiling" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="Ceiling" type="xs:duration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The maximum length of a retry interval. Once the retry interval has been incremented to a
+ value equal to or higher than the ceiling, further increments MUST NOT be applied.</p>
+ </xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <!-- ebMS2 -->
+
+ <xs:element name="ebMS2Channel" type="cppa:ebMS2ChannelType" substitutionGroup="cppa:Channel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures a channel using the ebXML Messaging version 2.0 protocol [ebMS2].</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ebMS2ChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The ebMS2 Channel Type is a subtype of the Channel Type.</p>
+ <p>A <a href="#Channel">Channel</a> that is an
+ <a href="#ebMS2Channel">ebMS2Channel</a> MUST NOT be linked
+ to a <a href="#Transport">Transport</a> element:
+ <ol>
+ <li>In case of a <em>Sync</em> transport channel binding for the response in a Two Way
+ exchange, which is indicated by the <em>asResponse</em> attribute being present
+ with a true value, and the channel being used by an <a href="#ActionBinding">ActionBinding</a> that
+ has a <em>replyTo</em> attribute linking the action to a request actions. That
+ request action then MUST be bound to a channel to provides a backchannel for
+ the synchronous response.
+ </li>
+ <li>In case of a synchronous standalone ebMS2 error or receipt signal, also
+ indicated by the <em>asResponse</em> attribute being present with a
+ true value.</li>
+ </ol>
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence>
+ <xs:element ref="cppa:ErrorHandling" minOccurs="0"/>
+ <xs:element ref="cppa:ReceiptHandling" minOccurs="0"/>
+ <xs:element ref="cppa:ebMS2ReliableMessaging" minOccurs="0"/>
+ <xs:element ref="cppa:ebMS2SecurityBinding" minOccurs="0"/>
+ <xs:element ref="cppa:ebMS2ChannelExtension" minOccurs="0" maxOccurs="unbounded"
+ />
+ </xs:sequence>
+ <xs:attribute name="securityBinding" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ebMS2SecurityBinding">ebMS2SecurityBinding</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ebMS2SecurityBinding">ebMS2SecurityBinding</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="errorHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ErrorHandling">ErrorHandling</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ErrorHandling">ErrorHandling</a> element. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="receiptHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ReceiptHandling">ReceiptHandling</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ReceiptHandling">ReceiptHandling</a> element. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="ebMS2ReliableMessaging" substitutionGroup="cppa:ReliableMessagingBinding">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Presence of this element specifies the use of the ebMS version 2.0 Reliable Messaging
+ protocol [ebMS2] for messages exchanged using this channel. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:ReliableMessagingBindingType">
+ <xs:sequence> </xs:sequence>
+ <xs:attribute name="actor" type="cppa:ebMS2ActorType" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>actor</em> attribute specifies the target of the
+ ebMS2 <em>AckRequested</em> element.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="ordered" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute specifies if the ebMS2 <em>MessageOrder</em> module
+ is to be used.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:simpleType name="ebMS2ActorType">
+ <xs:annotation>
+ <xs:documentation>The type of ebMS2 actor.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:anyURI">
+ <xs:enumeration value="urn:oasis:names:tc:ebxml-msg:actor:nextMSH"/>
+ <xs:enumeration value="urn:oasis:names:tc:ebxml-msg:actor:toPartyMSH"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+
+ <xs:element name="ebMS2SecurityBinding" substitutionGroup="cppa:ChannelFeature"
+ type="cppa:ebMS2SecurityBindingType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Specifies the use of the ebMS2 security module.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ebMS2SecurityBindingType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element ref="cppa:Signature" minOccurs="0"/>
+ <xs:element ref="cppa:Encryption" minOccurs="0"/>
+ <xs:any namespace="##other" processContents="lax" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="ebMS2ChannelExtension" abstract="true" type="cppa:ebMS2ChannelExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract ebMS2Channel extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ebMS2ChannelExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract ebMS2Channel Extension type</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelExtensionType"> </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+
+
+ <!-- ebMS3 -->
+
+ <xs:element name="ebMS3Channel" type="cppa:ebMS3ChannelType" substitutionGroup="cppa:Channel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures a channel using the ebMS3 messaging protocol
+ [EBMS3CORE,EBMS3PART2, AS4-Profile, ebMS-saml-conformance].
+ Both user messages and
+ signal messages use ebMS3 channels. When bound to HTTP or another protocol that
+ supports bidirectional communication, an ebMS3 channel MAY either use the forward
+ channel (from the initiator to the responder) or the backchannel (which flows in
+ the reverse direction).
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ebMS3ChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The ebMS3 Channel Type is a subtype of the Web Service Channel Binding Type. </p>
+ <p>Use of an <a href="#ebMS3Channel">ebMS3Channel</a> that is linked to a <a href="#Transport">Transport</a> obliges the
+ user of the channel to initiate that <a href="#Transport">Transport</a>.
+ The transport binding is
+ referenced using the <em>transport</em> attribute.
+ </p>
+ <p>An <a href="#ebMS3Channel">ebMS3Channel</a> MUST NOT be linked
+ to a <a href="#Transport">Transport</a> element in the following cases:</p>
+ <ol>
+ <li>In case of a <em>Pull</em> transport channel binding, which is indicated by
+ presence of a <a href="#PullHandling">PullHandling</a> child element.</li>
+ <li>In case of a <em>Sync</em> transport channel binding for the response in a Two Way
+ exchange, which is indicated by the <em>asResponse</em> attribute being present
+ with a true value, and the channel being used by an <a href="#ActionBinding">ActionBinding</a> that
+ has a <em>replyTo</em> attribute linking the action to a request actions. That
+ request action then MUST be bound to a channel that provides a backchannel for
+ the synchronous response.
+ </li>
+ <li>In case of a synchronous standalone ebMS3 error or receipt signal, also
+ indicated by the <em>asResponse</em> attribute being present with a true value.</li>
+ <li>In case of a multi-hop message, which is expressed using the value
+ <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/part2/200811/nextmsh</em>
+ for the <em>actorOrRole</em> attribute.
+ </li>
+ </ol>
+ <p>For these cases, the value of the ebMS3 <em>PMode.MEPbinding</em> parameter can
+ therefore
+ be derived from the presence or absence of the <a href="#PullHandling">PullHandling</a> element and the
+ <em>asResponse</em> attribute..
+ </p>
+ <p>Note that the list is non-exhaustive, because extensions of ebMS3 or CPPA3 may
+ define additional cases.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:WSChannelType">
+ <xs:sequence>
+ <xs:element ref="cppa:ErrorHandling" minOccurs="0"/>
+ <xs:element ref="cppa:ReceiptHandling" minOccurs="0"/>
+ <xs:element ref="cppa:PullHandling" minOccurs="0"/>
+ <xs:element ref="cppa:Compression" minOccurs="0"/>
+ <xs:element ref="cppa:Bundling" minOccurs="0"/>
+ <xs:element ref="cppa:Splitting" minOccurs="0"/>
+ <xs:element ref="cppa:AlternateChannelId" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ebMS3ChannelExtension" minOccurs="0" maxOccurs="unbounded"
+ />
+ </xs:sequence>
+ <xs:attribute name="mpc" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>mpc</em> attribute corresponds to the ebMS3 Core
+ <em>PMode[1].BusinessInfo.MPC</em> parameter. Its absence is equivalent to
+ presence with the value
+ <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/core/200704/defaultMPC</em>.
+ </p>
+ <p>Whereas MPC is a <em>BusinessInfo</em> parameter in ebMS3, it is defined at the
+ channel level in CPPA. This allows alternative channels to specify alternative
+ MPCs.
+ </p>
+ <p>The <em>mpc</em> attribute MUST only be used by channels used by UserMessages.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="submpcext" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>The <em>submpcext</em> attributes corresponds to the
+ AS4 <em>Pmode[1].BusinessInfo.subMPCext</em> parameter.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="actorOrRole" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>This attribute can be used to target the ebMS <em>Messaging</em>
+ header to a particular actor or role.
+ The value <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/part2/200811/nextmsh</em>
+ indicates that the message
+ is processed as defined in the Multi-Hop Messaging feature of the ebMS3,
+ Part 2 Advanced Features specification [EBMS3PART2].
+ This attribute does not control the actor/role on
+ other SOAP headers, such as the the WS-Security header. It relates to the
+ P-Mode parameter <em>Pmode[1].Protocol.AddActorOrRoleAttribute</em>.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="includePmode" type="xs:boolean" default="false">
+ <xs:annotation>
+ <xs:documentation>This attribute can be used to specify if a <em>pmode</em> attribute
+ is to be included in an ebMS3 message. If the value for
+ <em>includeAgreementRef</em> is <em>false</em>, this attribute MUST NOT be
+ set to <em>true</em>.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="includeAgreementRef" type="xs:boolean" default="true">
+ <xs:annotation>
+ <xs:documentation>This attribute can be used to specify if an <em>AgreementRef</em> element
+ is to be included in an ebMS3 message.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="errorHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ErrorHandling">ErrorHandling</a>
+ element.
+ If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ErrorHandling">ErrorHandling</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="receiptHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ReceiptHandling">ReceiptHandling</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ReceiptHandling">ReceiptHandling</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="compression" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#Compression">Compression</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#Compression">Compression</a>.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="splitting" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#Splitting">Splitting</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#Splitting">Splitting</a>.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="bundling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#Bundling">Bundling</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#Bundling">Bundling</a>.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+ <xs:element name="ebMS3ChannelExtension" abstract="true" type="cppa:ebMS3ChannelExtensionType">
+ <xs:annotation>
+ <xs:documentation>An abstract ebMS3Channel extension element</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ebMS3ChannelExtensionType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>An abstract ebMS3Channel Extension type</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelExtensionType"> </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+
+
+ <!-- ebMS2 and ebMS3 Error Handling -->
+
+ <xs:element name="ErrorHandling" type="cppa:ErrorHandlingType"
+ substitutionGroup="cppa:ChannelFeature">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#ErrorHandling">ErrorHandling</a> element specifies how
+ errors are handled for the exchange.</p>
+ <p>CPPA2 used the <em>defaultMshChannelId</em> attribute on <a href="#PartyInfo">PartyInfo</a> to express the
+ channel to use for asynchronous signals, such as errors.
+ As a consequence, in CPPA2, either
+ all errors are signed or none of them is.
+ In CPPA3, the channel is referenced
+ from the <em>SenderErrorsReportChannelId</em> and/or <em>ReceiverErrorsReportChannelId</em>
+ elements. As a consequence, in CPPA3 whether errors are to be signed can be specified for
+ each (synchronous or asynchronous) channel separately.
+ </p>
+ <p>CPPA2 did not specify if synchronous errors are signed or not. In CPPA3, this can be specified
+ for the referenced channel.</p>
+ <p>With ebMS2, ebMS3 and AS4, a reference to a signed channel expresses a recommendation on the
+ MSH to sign messages using the specified channel. This is a best effort obligation, as it
+ is not possible or desirable in all circumstances (for example, in case of errors)
+ to sign the message. </p>
+ <p>The ebMS3 and AS4 specifications do not specify if errors are signed or not, and do not
+ provide PMode parameters to control signing. With CPPA3, this can be configured.</p>
+ <p>Absence of the <em>DeliveryFailuresNotifyProducer</em>,
+ <em>ProcessErrorNotifyConsumer</em> and
+ <em>ProcessErrorNotifyProducer</em>elements is equivalent to
+ being present with a value <em>false</em>.
+ </p>
+ <p>CPPA3 does not provide a separate element for the
+ <em>PMode[1].ErrorHandling.Report.MissingReceiptNotifyProducer</em> PMode parameter,
+ as defined in the AS4 specification for its reception awareness feature [AS4-Profile].
+ If reception awareness is used with AS4, this parameter is assumed to be present with a
+ true (or false, respectively) value if the CPPA3 the <a
+ href="#ProcessErrorNotifyProducer">ProcessErrorNotifyProducer</a> element
+ is present with a true value (or true, respectively).
+ Situations where one is true and the other false are not not supported
+ [EBXMLMSG110].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ErrorHandlingType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element minOccurs="0" ref="cppa:DeliveryFailuresNotifyProducer"/>
+ <xs:element minOccurs="0" ref="cppa:ProcessErrorNotifyConsumer"/>
+ <xs:element minOccurs="0" ref="cppa:ProcessErrorNotifyProducer"/>
+ <xs:element minOccurs="0" ref="cppa:SenderErrorsReportChannelId"/>
+ <xs:element minOccurs="0" ref="cppa:ReceiverErrorsReportChannelId"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="ProcessErrorNotifyConsumer" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p/>
+ <p>This element corresponds to the ebMS3
+ <em>PMode[1].ErrorHandling.Report.ProcessErrorNotifyConsumer</em> parameter.
+ Its definition is provided in the ebMS3 Core Specification.
+ Absence of the element is equivalent to presence with a false value.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="DeliveryFailuresNotifyProducer" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element corresponds to the ebMS3
+ <em>PMode[1].ErrorHandling.Report.DeliveryFailuresNotifyProducer</em> parameter.
+ Its definition is provided in the ebMS3 Core Specification.
+ Absence of the element is equivalent to presence with a false value.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ProcessErrorNotifyProducer" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element corresponds to the ebMS3
+ <em>PMode[1].ErrorHandling.Report.ProcessErrorNotifyProducer</em> parameter.
+ Its definition is provided in the ebMS3 Core Specification.
+ Absence of the element is equivalent to presence with a false value.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SenderErrorsReportChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The ebMS3 <em>PMode[1].ErrorHandling.Report.SenderErrorsTo</em> parameter identifies the address
+ to which to send ebMS errors generated by the MSH that was trying to send the message in error.
+ In CPPA3, the <em>SenderErrorsReportChannelId</em> identifies this channel, which can be configured
+ as any channel. To avoid errors-on-errors, the identified channel MUST NOT itself
+ have <a href="#ErrorHandling">ErrorHandling</a> specified.
+ </p>
+
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ReceiverErrorsReportChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The ebMS3 <em>PMode[1].ErrorHandling.Report.ReceiverErrorsTo</em> parameter identifies the address
+ to which to send ebMS errors generated by the MSH that receives the message in error; e.g. this
+ may be the address of the MSH sending the message in error.
+ In CPPA3, the <em>ReceiverErrorsReportChannelId</em> identifies this channel, which can be
+ configured
+ as any channel. To avoid errors-on-errors, the identified channel MUST NOT itself
+ have <a href="#ErrorHandling">ErrorHandling</a> specified. </p>
+ <p>The functionality of the ebMS3 <em>PMode[1].ErrorHandling.Report.AsResponse</em> is expressed
+ by the presence of an <em>asResponse</em> attribute with value <em>true</em> and absence of a
+ specified <a href="#Transport">Transport</a> for the referenced channel</p>
+ <p>For use with the multihop feature defined in [EBMS3PART3], the use of WS-Addressing
+ as specified in the
+ <em>Pmode[1].Errorhandling.Report.SenderErrorsTo.Addressing</em>
+ parameter and its sub-parameters is specified with the referenced channel.
+ Similarly, to specify, for the parameter
+ <em>Pmode[1].ErrorHandling.Report.ReceiverErrors.ReplyPattern</em>, the value “pull†defined
+ in section 6.5 of [EBMS3PART2], the referenced channel can specify a <a href="#PullHandling">PullHandling</a>
+ element.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Receipt Handling -->
+
+ <xs:element name="ReceiptHandling" type="cppa:ReceiptHandlingType"
+ substitutionGroup="cppa:ChannelFeature">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Presence of the <a href="#ReceiptHandling">ReceiptHandling</a> element indicates that
+ message receipts must be
+ reported by a <em>Receipt</em> signal. Absence of the element indicates that
+ no <em>Receipt</em> is to be transmitted. </p>
+ <p>For protocols like ebMS2 and EDIINT the sender is expected to indicate in the message whether
+ or not a receipt is requested. The presence or absence of this element SHOULD be set in
+ accordance with presence or absence of <a href="#ReceiptHandling">ReceiptHandling</a>.
+ </p>
+ <p>When used with EDIINT, the type of receipt (signed or unsigned) and the channel
+ (synchronous or asynchronous) to be used can be requested by the sending MSH. In a <a href="#CPA">CPA</a>, the
+ <a href="#ReceiptHandling">ReceiptHandling</a> element expresses an agreement behaviour using the
+ definition of the referenced <a href="#ReceiptChannelId">ReceiptChannelId</a>.
+ </p>
+ <p>The <a href="#ReceiptHandling">ReceiptHandling</a> element has two sub-elements:</p>
+ <ul>
+ <li>The <a href="#ReceiptFormat">ReceiptFormat</a> MUST NOT be used in protocols that
+ have a single pre-defined receipt
+ format. In EDIINT, the receipt format is fixed to be a MIME multipart/report with
+ a report-type of
+ <em>disposition-notification</em>. The <a href="#ReceiptFormat">ReceiptFormat</a>
+ element therefore MUST NOT be used.
+ As AS4 supports two types of receipts,
+ the <a href="#ReceiptFormat">ReceiptFormat</a> element MUST be provided for each
+ AS4 <a href="#ebMS3Channel">ebMS3Channel</a>.</li>
+ <li>The <a href="#ReceiptChannelId">ReceiptChannelId</a> element specifies the channel
+ to use to exchange receipts.</li>
+ </ul>
+
+ <h3>EDIINT</h3>
+
+ <p>For EDIINT, the <a href="#ReceiptHandling">ReceiptHandling</a> element configures the
+ processing of EDIINT Message Disposition
+ Notifications (MDNs).
+ In a <a href="#CPP">CPP</a> <a href="#ReceiptHandling">ReceiptHandling</a> configures the receipt
+ processing that a Party expects. In a <a href="#CPA">CPA</a>, it configures the receipt processing
+ that a Party and its CounterParty have agreed to. If a <a href="#ReceiptHandling">ReceiptHandling</a> element is present, an
+ MDN SHOULD be requested.
+ In EDIINT, such a request is made using the MDN-request-header <em>Disposition-notification-to</em>.
+ If a <a href="#ReceiptHandling">ReceiptHandling</a> element is not present, an MDN SHOULD NOT be
+ requested and the MDN-request-header
+ SHOULD NOT be present.
+ </p>
+ <p>In CPPA3, the receipt channel identified using the <a href="#ReceiptChannelId">ReceiptChannelId</a>
+ element in
+ <a href="#ReceiptHandling">ReceiptHandling</a> element in an EDIINT channel is the channel over
+ which receipts are exchanged.
+ For EDIINT, the identified channel MUST be of a subtype of <em>EDIINTChannel</em>.
+ Note that AS2 allows MDNs to be returned using SMTP. In that case, the referring
+ <em>EDIINTChannel</em> is
+ an <a href="#AS2Channel">AS2Channel</a> that includes <a href="#ReceiptChannelId">ReceiptChannelId</a> that actually identifies an
+ <a href="#AS2Channel">AS2Channel</a> bound to an SMTP transport.
+ </p>
+ <p>In CPPA3, synchronous or asynchronous processing of EDIINT receipts is expressed
+ by the <em>asResponse</em> and
+ <em>transport</em> attributes. </p>
+ <p>AS1 only supports asynchronous MDNs. The Receiver is expected to return the MDN to the address
+ specified in the
+ <em>Disposition-notification-to</em> header on the message for which a receipt is requested.
+ In CPPA3, the <em>asResponse</em> attribute on the referenced <a href="#ReceiptChannelId">ReceiptChannelId</a> MUST be absent or present with a
+ false value. The <em>transport</em> attribute is REQUIRED and MUST specify an SMTP transport.
+ Its value is
+ the address the MDN is sent to.
+ </p>
+ <p>AS2 supports synchronous and asynchronous MDNs:</p>
+ <ul>
+ <li>If the <em>asResponse </em>attribute is present on the receipt channel with the
+ value <em>true</em>, the channel
+ is a synchronous channel, which uses the backchannel offered by the <a href="#AS2Channel">AS2Channel</a> on which the
+ <a href="#ReceiptHandling">ReceiptHandling</a> element occurs.
+ In this case, the <em>transport</em> attribute MUST NOT be present. </li>
+ <li>If the <em>asReponse</em> attribute is absent, or present with a value <em>false</em>,
+ the channel is an
+ asynchronous channel. It uses a separate transport connection that is identified using
+ the value of the
+ <em>transport</em> attribute, which MUST be present and which MUST reference an
+ EDIINT transport.
+ The value of the <a href="#Endpoint">Endpoint</a> element in the referenced transport
+ SHOULD be used as value for the
+ <em>Receipt-Delivery-Option</em>.
+ Note that AS2 allows MDNs to use other transports than HTTP.
+ </li>
+ </ul>
+ <p>AS3 only supports asynchronous MDNs.</p>
+ <p>For signed messages, AS2 and AS3 specify that the algorithm used to calculate the MIC MUST be
+ the same as that used on the message that was signed. In CPPA3, this is a constraint on the
+ <a href="#SignatureAlgorithm">SignatureAlgorithm</a> element in <a href="#Signature">Signature</a> on the referenced <a href="#ReceiptChannelId">ReceiptChannelId</a>.
+ If the message is not signed, then AS2 and AS3 specify that the SHA-1 algorithm
+ SHOULD be used. </p>
+ <p>In EDIINT, a signed MDN can be requested by setting the <em>signed-receipt-protocol</em>
+ and <em>signed-receipt-micalg</em> headers. If signing of EDIINT MDNs is expected to be
+ requested, in CPPA3:
+ </p>
+ <ul>
+ <li>The channel referenced using <a href="#ReceiptChannelId">ReceiptChannelId</a> MUST
+ have a <a href="#Signature">Signature</a> element. </li>
+ <li>This <a href="#Signature">Signature</a> element MAY contain a <em>SignatureFormat</em>.
+ For AS2 and AS3, the only accepted value is <em>pkcs7-signature</em>. This selects the
+ S/MIME detached signature format.
+ For AS1, the accepted values are <em>pkcs7-signature</em> and <em>pgp-signature</em>.
+ </li>
+ <li>This <a href="#Signature">Signature</a> element MUST also contain one of
+ more <a href="#SignatureAlgorithm">SignatureAlgorithm</a> elements.
+ To select one of the two supported values for MIC algorithm, the value of the
+ <a href="#SignatureAlgorithm">SignatureAlgorithm</a>
+ element or elements MAY be set to <em>http://www.w3.org/2000/09/xmldsig#sha1</em> or
+ <em>http://www.w3.org/2001/04/xmldsig-more#md5</em>. These values translate to
+ the <em>sha1</em> and
+ <em>md5</em> <micalg> values. Note that, while RFC4130 only supports SHA1 and MD5,
+ EDIINT
+ implementations support more modern algorithm like sha-224, sha-256, sha-384 and sha-512.
+ </li>
+ </ul>
+ <p>Note that in EDIINT, MDNs can be requested per message and the configuration can be set per
+ message.
+ This means that EDIINT software MAY override the CPPA3 configuration at runtime. In case an
+ MDN is
+ not requested by the sender but the Receiver is expecting a request, the expected behaviour
+ is undefined in this specification.
+ </p>
+
+ <h3>ebMS3 Core</h3>
+
+ <p>In ebMS3 Core, receipt handling is considered part of the security
+ processing mode parameters as it is closely linked to non-repudiation of receipt.
+ CPPA3 defines receipt handling as a feature of the <a href="#ebMS3Channel">ebMS3Channel</a>.
+ This element
+ provides the functionality of the ebMS3 <em>PMode[1].Security.SendReceipt</em> parameter.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ReceiptHandlingType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element minOccurs="0" ref="cppa:ReceiptFormat"/>
+ <xs:element minOccurs="1" ref="cppa:ReceiptChannelId"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="ReceiptFormat">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#ReceiptFormat">ReceiptFormat</a> allows choice of the receipt format to be used for
+ protocols like ebMS3 that support multiple receipt formats, which can be profiled
+ in profiles such as AS4.
+ </p>
+ <p>When used with AS4, the allowed values are
+ <em>NonRepudiationInformation</em> for Non-Repudation
+ of Receipt or
+ <em>UserMessage</em> for Reception Awareness.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="cppa:non-empty-string"/>
+ </xs:simpleType>
+ </xs:element>
+
+ <xs:element name="ReceiptChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <h3>Definition</h3>
+
+ <p>
+ The <a href="#ReceiptChannelId">ReceiptChannelId</a> element references the channel
+ over which a receipt
+ is exchanged. As receipts themselves are not sent reliably, the referenced channel MUST NOT
+ itself specify any <a href="#ReceiptHandling">ReceiptHandling</a>.
+ </p>
+ <h3>ebMS3</h3>
+ <p>The ebMS3 <em>PMode[1].Security.SendReceipt.ReplyPattern</em> parameter indicates
+ whether the Receipt signal is to be sent as a callback (value "callback"), or synchronously in
+ the back-channel response (value "response"). In CPPA3, this (and more) information is defined
+ for the referenced channel.
+ The referenced channel also specifies any <em>Pmode[1].Security.SendReceipt.ReplyTo</em> value.
+ In [EBMS3PART2], an additional value <em>pull</em> is defined to allow pulling of receipts in a
+ multihop context. This is achieved in CPPA3 by specifying a <a href="#PullHandling">PullHandling</a> element for
+ the receipt channel.
+ </p>
+ <p>When used with a Web Services Reliable Messaging protocol, the channel also covers
+ the <em>PMode[1].Reliability.AtLeastOnce.Contract.AcksTo</em>,
+ <em>PMode[1].Reliability.AtLeastOnce.Contract.AckResponse</em> and
+ <em>PMode[1].Reliability.AtLeastOnce.ReplyPattern</em> parameters.
+ </p>
+ <h3>EDIINT</h3>
+ <p>When used with EDIINT, if the referenced receipt channel is signed, the sending
+ MSH MUST request a signed MDN. If the referenced receipt channel is not signed,
+ the sending MSH MUST not request a signed MDN.
+ </p>
+ <h3>CPPA2</h3>
+ <p>The <a href="#ReceiptChannelId">ReceiptChannelId</a> element replaces the functions of three
+ CPPA2 elements
+ and attributes: </p>
+ <ol>
+ <li>The <em>syncReplyMode</em> attribute on <em>MessagingCharacteristics</em> in CPPA2 can be
+ used to
+ specify whether receipts are expected synchronously or asynchronously. In CPPA3, this is a
+ characteristic of the referenced receipt channel.</li>
+ <li>CPPA2 used the <em>defaultMshChannelId</em> attribute on <a href="#PartyInfo">PartyInfo</a> to express the
+ channel to use for asynchronous signals, such as receipts. In CPPA3, the channel is referenced
+ from an <em>ebMS2ReliableMessaging</em> element.
+ In CPPA2, either all receipts are signed or none. In CPPA3, this can be specified for
+ each (synchronous or asynchronous) channel separately.</li>
+ <li>In CPPA2, the <em>ackSignatureRequested</em> attribute on <em>MessagingCharacteristics</em>
+ expressed whether the receipt message is to be signed. Whereas this can be specified for
+ each channel, only one asynchronous channel could be specified for receipts, which can only be
+ signed or unsigned.
+ In CPPA3 it is possible to specify that some asynchronous receipts are to be signed and
+ others not.</li>
+ </ol>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="PullHandling">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures the use of ebMS3 pulling to transfer user messages.
+ It specifies the channel that the pull request MUST use.
+ </p>
+ <p>Extension elements can be added to the content of this element to further configure pull handling.
+ Such extensions could be product-specific or defined in profiles.
+ </p>
+ <p>Note that the MPC to pull from is specified in the ebMS3Channel used by the (pulled) user message,
+ not in the pull channel.
+ </p>
+ <p>When using reliable messaging, the referenced channel MAY have its own specification
+ on whether it uses reliable messaging. This means
+ that the <em>Pmode[1].Reliability.AtLeastOnce.Contract.ReliablePull</em>
+ parameter defined in [EBMS3PART2]
+ is not needed, as the use of reliable messaging for the pull signal is specified independently of the
+ use of reliable messaging for the user messages being pulled.
+ </p>
+ <p>Similarly, the referenced channel MAY specify the use of WS-Addressing, thus covering the
+ <em>Pmode[1].Reliability.AtLeastOnce.Contract.AcksTo.Addressing</em> and
+ <em>Pmode[1].Reliability.AtLeastOnce.Contract.AcksTo.Addressing.EPR</em> parameters.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:PullChannelId" maxOccurs="1"/>
+ <xs:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="unbounded"
+ />
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="PullChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>
+ If the <a href="#PullChannelId">PullChannelId</a> element is specified for a <a href="#Channel">Channel</a> associated
+ with an action binding, the
+ <a href="#ebMS3Channel">ebMS3Channel</a> exchanges the ebMS3 message for this action
+ using the <em>Pull</em>
+ transport channel binding.
+ The <em>Pull</em> request uses the referenced channel <a href="#PullChannelId">PullChannelId</a>,
+ which itself MUST have an associated <a href="#Transport">Transport</a> element.
+ That channel provides an
+ anonymous back-channel that this referring document exchange uses.
+ The <a href="#Channel">Channel</a> for the action binding MUST NOT itself be linked to a
+ <a href="#Transport">Transport</a>.
+ </p>
+ <p>The referenced channel MUST be a channel of type <a href="#ebMS3Channel">ebMS3Channel</a>. If the pull
+ channel is to be authorized using a WS-Security header targeted to <em>ebms</em> actor or role
+ (see ebMS3 Core, section 7.10), then the referenced channel MUST have a
+ <em>cppa3:WSSecurityBinding</em> element with an <em>ebms</em> value for the attribute
+ <em>actorOrRole</em> which has a <em>UserAuthentication</em> element.
+ That element corresponds to the
+ ebMS3
+ <em>PMode.{Initiator/Reponder}Responder.Authorization.{username/password}</em> parameters.
+ </p>
+ <p>If the <a href="#PullChannelId">PullChannelId</a> element is specified, then the
+ <em>asResponse</em> attribute
+ MUST NOT be specified with a value <em>true</em> and the <em>transport</em> attribute MUST
+ be absent.</p>
+ <p>
+ If the <a href="#PullChannelId">PullChannelId</a> element is not specified for a
+ <a href="#Channel">Channel</a>,
+ and a <em>transport</em> attribute is specified, the message is exchanged using
+ a <em>Push</em> transport channel binding.
+ This <a href="#Channel">Channel</a> MUST be linked to a <a href="#Transport">Transport</a> that specifies
+ the connection to be set up for the exchange.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- WS-Addressing -->
+
+ <xs:element name="Addressing" type="cppa:AddressingType" substitutionGroup="cppa:ChannelFeature">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Addressing">Addressing</a> element supports presence and configuration of
+ WS-Addressing headers
+ in Web Services messaging. </p>
+ <p>The <a href="#Endpoint">Endpoint</a> element configures the <em>wsa:To</em> element.</p>
+ <p>The <em>Address</em> element configures the <em>wsa:Action</em> element. </p>
+
+ <p>The use of any of the sub-elements and the semantics of their presence or absence MAY be
+ further specified in message protocols or profiles that use this element.
+ </p>
+
+ <p>CPPA3 does not provide a separate <em>FaultTo</em> element to statically configure agreed
+ fault channels.
+ It can be specified
+ using the <a href="#Endpoint">Endpoint</a> and reference parameter elements on a separate
+ channel that is referenced
+ using the <em>FaultChannelId</em> on a <em>FaultHandling</em> element on the channel.
+ </p>
+ <p>CPPA3 does not provide a separate <em>ReplyTo</em> element to statically configure agreed
+ response channels.
+ In a Two Way message
+ exchange, the <a href="#ActionBinding">ActionBinding</a> for the response action has its
+ own channel
+ definition which can include its own WS-Addressing <a href="#Endpoint">Endpoint</a> and
+ reference parameters.
+ </p>
+ <p>The <em>RelatesTo</em> and <em>MessageId</em> elements are per-message elements and are not
+ configured at the channel level.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="AddressingType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element ref="cppa:Endpoint"/>
+ <xs:element ref="cppa:Action"/>
+ <xs:element ref="cppa:From" minOccurs="0"/>
+ <xs:element ref="cppa:AbsReferenceParameter" minOccurs="0" maxOccurs="unbounded"
+ />
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="Action" type="cppa:ActionType">
+ <xs:annotation>
+ <xs:documentation>A Web Services <em>Action</em>.</xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <xs:complexType name="ActionType">
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="name" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>The <em>name</em> value of the action.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:element name="From" type="cppa:EndpointReferenceType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element allows a <a href="#Channel">Channel</a> to set the <a href="#From">From</a> header value in
+ Web Services <a href="#Addressing">Addressing</a>.
+ </p>
+ <p>Note that message protocols or profiles MAY have conventions to derive the
+ value of this header from other content in the CPPA3 document, such as
+ the <a href="#PartyId">PartyId</a> element. If that is the case, the element
+ MUST NOT be used in the CPPA3 document.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="EndpointReferenceType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This type definition defines a WS-Addressing <em>EndpointReferenceType</em>.
+ In the CPPA3 schema
+ it is only used for the <a href="#From">From</a> element as the <em>FaultTo</em>
+ and <em>ReplyTo</em>
+ endpoints are determined using the <em>FaultHandling</em> and <a href="#ReceiptHandling">ReceiptHandling</a>
+ elements.
+ </p>
+ <p>No <em>Metadata</em> element is provided, as CPPA3 provides mechanisms to
+ statically define
+ behavior, policies and capabilities of the endpoint. This does not preclude
+ Web Services-based message protocols or profiles described using CPPA3 to
+ include dynamic metadata in SOAP messages.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:Endpoint"/>
+ <xs:element ref="cppa:AbsReferenceParameter" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+
+
+ <xs:element name="AbsReferenceParameter" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>AbsReferenceParameter</em> element is an abstract element that can be
+ substituted by either a <em>ReferenceParameter</em> structure or by elements
+ that describe how such parameters are to be constructed.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="AbsReferenceParameterType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>The abstract type of an <em>AbsReferenceParameter</em>.</xs:documentation>
+ </xs:annotation>
+ </xs:complexType>
+
+ <xs:element name="ebMS3InferredRoutingInput" substitutionGroup="cppa:AbsReferenceParameter"
+ type="cppa:ebMS3RoutingInputType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a <em>RoutingInput</em> reference parameter as specified in
+ the ebMS3 Part 2, Advanced Features specification, of which the content is derived
+ from the content of a related ebMS3 <em>UserMessage</em> for use in multi-hop messaging.
+ The specification distinguishes two situations:
+ </p>
+ <ul>
+ <li><em>RoutingInput</em> attached to an ebMS3 initiating signal message, in
+ particular to
+ a <em>Pull</em> signal message. The content of the <em>RoutingInput</em> is
+ specified in section 2.6.1 of [EBMS3PART], item (2) of the numbered list,
+ second option,
+ <em>The EPR for the request signal to pull a user message can be inferred from the
+ P-Mode as follows ...</em>.
+ </li>
+ <li><em>RoutingInput</em> attached to response messages, in particular to
+ ebMS3 response signals such as errors and receipts.
+ The content of the reference parameter is generated as
+ specified in section 2.6.2 of [EBMS3PART], item (4) of the numbered list,
+ <em>Inferred RoutingInput for the reverse path</em>.
+ </li>
+ </ul>
+ <p>Common to all inferred <em>RoutingInput</em> parameters is that:</p>
+ <ul>
+ <li>The content of the <a href="#From">From</a> and <em>To</em> elements is swapped.</li>
+ <li>The value of the <em>Service</em> element and its <em>type</em> attribute are copied.</li>
+ <li>The content of the <em>Action</em> element and <em>mpc</em> attribute
+ are set to
+ the values of the related user message, concatenated with optional suffixes specified in
+ <em>ActionSuffix</em> and <em>MPCSuffix</em> element respectively. </li>
+ </ul>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ebMS3RoutingInputType">
+ <xs:complexContent>
+ <xs:extension base="cppa:AbsReferenceParameterType">
+ <xs:sequence>
+ <xs:element ref="cppa:ActionSuffix" minOccurs="0"/>
+ <xs:element ref="cppa:MPCSuffix" minOccurs="0"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="ActionSuffix" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a string that MUST be appended to the value of the <em>Action</em> element in
+ the user message from which the reference parameter is derived.
+ </p>
+ <p>The value <em>.pull</em> is the value specified in the second of the last three bullets in section
+ 2.6.1 of [EBMS3PART2].
+ </p>
+ <p>The value <em>.response</em>
+ is the value specified in the second bullet in the section 2.6.2 of [EBMS3PART2],
+ item (4) section. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="MPCSuffix" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a string that MUST be appended to the value of the <em>mpc</em> attribute
+ in the user message from which the reference parameter is derived.
+ The value <em>.response</em>
+ is the value specified in the second bullet in the section 2.6.2 of [EBMS3PART2],
+ item (4) section.
+ </p>
+ <p>If no <em>mpc</em> attribute is present in the user message from which the reference parameter is
+ derived, the reference parameter is to include an <em>mpc</em> attribute the value of which is
+ the concatenation of the default MPC value
+ <em>http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/core/200704/defaultMPC</em> followed by the
+ specified suffix.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Bundling -->
+
+ <xs:element name="Bundling" substitutionGroup="cppa:ChannelFeature" type="cppa:BundlingType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element enables support of a subset of the ebMS3 Part 2 Bundling feature, which allows multiple
+ user messages to be transferred in a single ebMS3 message. In the Part 2
+ specification, Bundling is configured per P-Mode. Bundling of different types of messages is
+ expressed as cross-references between P-Modes.
+ </p>
+ <p>In this CPPA3 schema, Bundling is defined at
+ the level of ebMS3 channels. If distinct actions are bound to a single ebMS3 channel with a
+ Bundling element, then user messages for these actions MAY be bundled subject
+ to the constraints specified in the element. This is similar to the
+ <em>Pmode[].bundling.compatibility.pmodelist</em> parameter. However, it means that in CPPA3
+ bundling can only be defined for P-Modes that have the same values for the P-Mode parameters that are
+ determined by the ebMS3Channel.
+ </p>
+ <p>Presence of the <em>Bundling</em> element is equivalent to the <em>Pmode[].bundling.policy</em>
+ with value <em>optional</em>.
+ </p>
+ <p>Bundling can be configured using the following sub-elements:</p>
+ <ol>
+ <li>The element <a href="#MaxSize">MaxSize</a> expresses the maximum size for the bundle. It encodes the
+ <em>Pmode[].bundling.maxsize</em> P-Mode parameter. This parameter defines the maximum size of a
+ message resulting from bundling. It includes the size of the SOAP envelope and any payloads in
+ MIME attachments.
+ </li>
+ <li>The element <em>MaxDelay</em> encodes the <em>Pmode[].bundling.maxdelay</em> P-Mode
+ parameter. This parameter (of type duration) defines the maximum time between the oldest message
+ unit and the newest message unit in a bundle, based on the <em>eb3:MessageInfo/eb3:Timestamp</em>
+ values of the message units. A receiving MSH SHOULD validate that the bundles satisfies
+ this requirement. A sending MSH MAY use this parameter to determine, for a submitted message
+ unit, to bundle it with other submitted messages , to send it by itself (as an unbundled
+ message) or to defer sending it (as other message units may be submitted later
+ that it could be bundled with).
+ </li>
+ <li>The <em>Policy</em> element encodes the <em>Pmode[].bundling.ordering.policy</em> parameter.
+ In [EBMS3PART2], this element is defined to have three values for <em>Policy</em>. Absence of
+ the CPPA3 <em>Ordering</em> element is equivalent to the ebMS3 P-Mode being present with
+ value <em>undefined</em> for <em>Policy</em>.
+ If the <em>Ordering</em> element is present, the <em>Policy</em> element MUST be present with a
+ value that indicates which of the other two policies applies to the channel.
+ </li>
+ <li>The <em>Scope</em> element encodes the <em>Pmode[].bundling.ordering.scope</em>
+ P-Mode parameter.</li>
+ </ol>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="BundlingType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element ref="cppa:MaxSize" minOccurs="0"/>
+ <xs:element name="MaxDelay" type="xs:duration" minOccurs="0"/>
+ <xs:element name="Ordering" minOccurs="0">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Policy" minOccurs="1">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="documentorder"/>
+ <xs:enumeration value="timestamp"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="Scope" minOccurs="0">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Expression" minOccurs="1"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <!-- Split, Join, Compress -->
+
+ <xs:element name="Splitting" substitutionGroup="cppa:ChannelFeature" type="cppa:SplittingType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element configures the use of the ebMS3 Part 2 Split, Join, Compress
+ Advanced Feature.</p>
+ <p>Presence of this element in an <a href="#ebMS3Channel">ebMS3Channel</a>
+ is equivalent to presence of
+ the <em>Pmode[].Splitting</em> P-Mode parameter.
+ The structure of the element reflects the P-Mode parameters defined for the feature:
+ </p>
+ <ul>
+ <li>The <a href="#Splitting_FragmentSize">FragmentSize</a> element encodes
+ the <em>Pmode[].Splitting.FragmentSize</em> P-Mode
+ parameter. </li>
+ <li>The optional list of <a href="#Property">Property</a> elements
+ encodes the <em>Pmode[].Splitting.RoutingProperties</em>
+ P-Mode parameter. Alternatively, a set of properties can be
+ referenced using the <em>propertySetId</em> attribute.
+ </li>
+ <li>The <a href="#JoinInterval">JoinInterval</a> encodes
+ the <em>Pmode[].Splitting.JoinInterval</em> parameter.</li>
+ </ul>
+ <p>The definition of the <a href="#ebMS3Channel">ebMS3Channel</a> that contains the
+ <a href="#Splitting">Splitting</a> applies to fragment messages. The channel
+ definition as it applies to the source (and hence target) message is
+ configured using an <a href="#ebMS3Channel">ebMS3Channel</a> referenced using the
+ <a href="#SourceChannelId">SourceChannelId</a> element.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SplittingType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelFeatureType">
+ <xs:sequence>
+ <xs:element name="FragmentSize" minOccurs="0" type="cppa:SizeType"/>
+ <xs:element ref="cppa:Property" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:CompressionAlgorithm" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:JoinInterval" minOccurs="0"/>
+ <xs:element ref="cppa:SourceChannelId" minOccurs="0" />
+ </xs:sequence>
+ <xs:attribute name="propertySetId" type="xs:IDREF" use="optional">
+ <xs:annotation>
+ <xs:documentation>A reference to a set of properties used for routing purposes.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="JoinInterval" type="xs:duration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#JoinInterval">JoinInterval</a> encodes the
+ <em>Pmode[].Splitting.JoinInterval</em> P-Mode parameter defined in
+ [EBMS3PART2]. </p>
+ <p>This element MAY be specified in a <a href="#CPP">CPP</a> for a Receiver transport.
+ It SHOULD NOT be set for a Sender transport.
+ In <a href="#CPA">CPA</a> formation, the value to be included in the
+ <a href="#CPA">CPA</a> is the Receiver value, if present.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SourceChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#SourceChannelId">SourceChannelId</a> is a reference to a definition
+ of the channel as it applies to the source message in case
+ <a href="#Splitting">Splitting</a> is used and the source message channel differs
+ from the fragment channel.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Alternate Channel -->
+
+ <xs:element name="AlternateChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This references an alternate channel that can be used by an MSH to make available
+ messages that could not be exchanged using the channel that references it. Multiple
+ occurrences of an <a href="#AlternateChannelId">AlternateChannelId</a> express
+ multiple alternative options.
+ </p>
+ <p>This supports an advanced feature of ebMS3 Part 2, called <em>Alternate MEP</em>,
+ which limits its use to offering a <em>Pull</em>-based access to response messages in
+ a synchronous Two Way MEP that could not be delivered in time to be transmitted over the
+ backchannel. That feature requires that at most one alternate channel is present.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- AS4 Reception Awareness and Reliable Messaging -->
+
+ <xs:element name="AS4ReceptionAwareness" substitutionGroup="cppa:ReliableMessagingBinding">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element configures the use of AS4 Reception Awareness.</p>
+ <p>The structure inherited from <a href="#ReliableMessagingBinding">ReliableMessagingBinding</a> provides
+ structure to configure the parameters
+ <em>PMode[1].ReceptionAwareness</em>,
+ <em>PMode[1].ReceptionAwareness.Retry</em>,
+ <em>PMode[1].ReceptionAwareness.Retry.Parameters</em>,
+ <em>PMode[1].ReceptionAwareness.DuplicateDetection</em> and
+ <em>PMode[1].ReceptionAwareness.DetectDuplicates.Parameters</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:ReliableMessagingBindingType">
+ <xs:sequence> </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="WSReliableMessagingBinding" substitutionGroup="cppa:ReliableMessagingBinding">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element configures the use of Web Services Reliable Messaging.</p>
+ <p>When used with WS-ReliableMessaging, the <a href="#ReceiptHandling">ReceiptHandling</a> element MUST
+ be included. When creating sequences, the <em>wsa:AcksTo</em> header value
+ MUST be taken from the channel identified in the <a href="#ReceiptChannelId">ReceiptChannelId</a>
+ element in <a href="#ReceiptHandling">ReceiptHandling</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:ReliableMessagingBindingType">
+ <xs:sequence>
+ <xs:element name="Protocol" minOccurs="1">
+ <xs:simpleType>
+ <xs:restriction base="xs:anyURI">
+ <xs:enumeration
+ value="http://docs.oasis-open.org/ws-rx/wsrm/v1.1/">
+ <xs:annotation>
+ <xs:documentation>WS-ReliableMessaging v1.1</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration
+ value="http://docs.oasis-open.org/ws-rx/wsrm/v1.2/">
+ <xs:annotation>
+ <xs:documentation>WS-ReliableMessaging v1.2</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration
+ value="http://docs.oasis-open.org/wsrm/2004/06/ws-reliability-1.1.xsd">
+ <xs:annotation>
+ <xs:documentation>WS-Reliability v1.1</xs:documentation>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element ref="cppa:ReceiptHandling" minOccurs="0"/>
+ <xs:element name="AckOnDelivery" type="xs:boolean" minOccurs="0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element corresponds to the
+ <em>PMode[1].Reliability.AtLeastOnce.Contract.AckOnDelivery</em> parameter.
+ This Boolean parameter indicates the semantics of acknowledgments that are
+ generated by the reliability module. See section 8.2 of [EBMS3CORE] for
+ specification.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="InOrder" type="xs:boolean" minOccurs="0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element corresponds to the
+ <em>PMode[1].Reliability.InOrder.Contract</em> parameter. See section
+ 8.2 of [EBMS3CORE] for
+ specification.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="StartGroup" type="xs:boolean" minOccurs="0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This parameter is a Boolean that indicates if messages matching this
+ P-Mode MUST be associated with a new reliability group or sequence.
+ For example, a particular <em>Service</em> and <em>Action</em>
+ may have the application semantics of
+ initiating a new ordered sequence of messages.</p>
+ <p>PMode parameter <em>PMode[1].Reliability.StartGroup</em>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Correlation" minOccurs="0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element maps to the ebMS3 PMode parameter
+ <em>PMode[1].Reliability.Correlation</em>g.</p>
+ <p>In ebMS3 Core, the following definition is provided:
+ This parameter tells how to correlate a message with an existing
+ reliability group or sequence. It is a comma-separated list of
+ XPath elements. Each one of these XPaths identifies an element or
+ attribute inside an <em>eb:UserMessage</em> or <em>eb:SignalMessage</em>,
+ and may include predicates.
+ </p>
+ <p>The content is a list of XPath <a href="#Expression">Expression</a> element.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Expression" minOccurs="1"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="TerminateGroup" type="xs:boolean" minOccurs="0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This parameter is a Boolean value that may be used to indicate if messages matching
+ this P-Mode must cause the closure of the reliability group or sequence with which
+ they correlate.</p>
+ <p>PMode parameter <em>PMode[1].Reliability.TerminateGroup</em>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ <xs:attribute name="receiptHandling" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>A reference to a reused <a href="#ReceiptHandling">ReceiptHandling</a> element. If
+ this attribute is present, there MUST NOT be a
+ child <a href="#ReceiptHandling">ReceiptHandling</a>. </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <!-- Transport Channel Binding -->
+
+ <xs:element name="TransportChannel" substitutionGroup="cppa:Channel">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#TransportChannel">TransportChannel</a> represents a direct implementation of
+ a <a href="#Channel">Channel</a> using a
+ referenced <a href="#Transport">Transport</a>, i.e. there is no messaging protocol
+ providing packaging or
+ other features on top of the specified transport.
+ </p>
+ <p>The <a href="#TransportChannel">TransportChannel</a> is provided to support
+ the following features:</p>
+ <ul>
+ <li>To support payload exchange using REST. In this case a reference MUST be provided using the
+ <em>transport</em> attribute to a <a href="#Transport">Transport</a> that is an HTTP POST.</li>
+ <li>To support the external payload feature, as used in ebMS2 and ebMS3. In this case there are
+ two <a href="#TransportChannel">TransportChannel</a>s involved:
+ <ol>
+ <li>One <a href="#TransportChannel">TransportChannel</a> that is a back-channel,
+ used to transport the
+ payload data. This channel can be bound to an action.</li>
+ <li>A separate <a href="#TransportChannel">TransportChannel</a> that creates
+ the back-channel. This channel
+ is to be defined separately and is referenced using
+ using <a href="#RequestChannelId">RequestChannelId</a>.
+ </li>
+ </ol>
+ </li>
+ </ul>
+ <p>A <a href="#TransportChannel">TransportChannel</a> MUST NOT be linked
+ to a <a href="#Transport">Transport</a> element using the <em>transport</em>
+ attribute in case the channel
+ uses a back-channel created by another channel. That other channel could be:
+ </p>
+ <ul>
+ <li>The request <a href="#TransportChannel">TransportChannel</a> used by the first leg
+ in a Two Way exchange
+ that is referenced by a <em>replyTo</em> attribute on the response action that uses
+ the back-channel. The response <a href="#TransportChannel">TransportChannel</a>
+ MUST have
+ an <em>asResponse</em> attribute present with a true value.
+ </li>
+ <li>An ad hoc <a href="#TransportChannel">TransportChannel</a> that is used purely to
+ provide the back-channel.
+ This channel is identified using the <a href="#RequestChannelId">RequestChannelId</a>.
+ </li>
+ </ul>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence>
+ <xs:element ref="cppa:RequestChannelId" minOccurs="0"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="RequestChannelId" type="xs:IDREF">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#RequestChannelId">RequestChannelId</a> identifies a channel that does not
+ serve to exchange any
+ payload and is not bound to an action. It provides a backchannel to another channel that
+ does carry any payload and is bound to an action.
+ </p>
+ <p>The use of <a href="#RequestChannelId">RequestChannelId</a> is similar to the ebMS3 <a href="#PullRequestId">PullRequestId</a>. The
+ difference is that the <a href="#PullRequestId">PullRequestId</a> also involves the use
+ of an ebMS3 envelope
+ containing a Pull signal, whereas a <a href="#RequestChannelId">RequestChannelId</a>
+ only serves to specify the use of
+ an transport channel request and involves no message protocol specific structures.
+ </p>
+ <p>A <a href="#TransportChannel">TransportChannel</a> that is used as a
+ <a href="#RequestChannelId">RequestChannelId</a> for use in ebMS2 and ebMS3
+ MUST be bound to an <a href="#HTTPTransport">HTTPTransport</a> that is specified to use the
+ HTTP GET method. This is different from all other current uses of
+ channels for use with ebMS2, AS2, ebMS3 and AS4.
+ </p>
+ <p>The <em>Address</em> URL that is used in the referenced transport MAY not be the
+ complete URL. It may be that the external payload involves a <em>href</em> that adds
+ a payload specific suffix.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- AMQP -->
+
+ <xs:element name="AMQPChannel" substitutionGroup="cppa:Channel" type="cppa:AMQPChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An <a href="#AMQPChannel">AMQPChannel</a> configures a channel using the OASIS Advanced Message
+ Queuing Protocol (AMQP) messaging protocol [amqp-core-messaging-v1.0]
+ which uses the AMQP transport protocols [amqp-core-transport-v1.0].
+ In this CPPA3 schema,
+ the <a href="#AMQPChannel">AMQPChannel</a> name is used for the element
+ to indicat that the element is a member of the <a href="#Channel">Channel</a> substitution group,
+ which in CPPA3 eis used for messaging protocols.
+ In AMQP Transport, <em>channels</em> relate to a division of
+ <em>connection</em>s into a negotiated number of independent unidirectional
+ channels [amqp-core-transport-v1.0]. This is a lower-level concept that is not to be confused
+ with the CPPA3 concept of an <a href="#AMQPChannel">AMQPChannel</a>.
+ </p>
+ <p>AMQP provides an Application Properties feature to allow routing or filtering of messages.
+ This feature can be used to encode <a href="#Property">Property</a> elements specified
+ at <a href="#ActionBinding">ActionBinding</a> level. Furthermore,
+ usage profiles of AMQP for use with CPPA3 MAY use this feature to encode the CPPA3
+ <em>Service</em> and <em>Action</em> values in AMQP messages.
+ </p>
+ <p>The OASIS AMQP Standard defines its own TCP-based transport protocol. A CPPA document that
+ includes one or more <a href="#AMQPChannel">AMQPChannel</a> elements that use the AMQP transport
+ protocol MUST include one or more <a href="#AMQPTransport">AMQPTransport</a> elements and
+ reference them using the <em>transport</em> attribute value. Configuration of AMQP transport
+ links bound to AMQP channels reflect the actions bound to the channel.
+ </p>
+ <p>As any CPPA3 <a href="#Channel">Channel</a>, an <a href="#AMQPChannel">AMQPChannel</a> MAY
+ specify a <a href="#MaxSize">MaxSize</a>. In AMQP link attachment, this value MUST be used as as
+ value for the <em>max-message-size</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="AMQPChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The type definition of an <a href="#AMQPChannel">AMQPChannel</a>
+ supports configuration of some parameters used in AMQP performatives
+ and setting the AMQP protocol version.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence> </xs:sequence>
+ <xs:attribute name="version" type="cppa:non-empty-string" default="1.0">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The AMQP protocol version supported by the container. If a party supports
+ multiple AMQP protocol versions, its CPP can bind its actions to multiple distinct
+ <a href="#AMQPChannel">AMQPChannel</a> elements that have different values
+ for the <em>version</em> attribute, but that listen on the same TCP port.
+ The actual version used is at run-time determined in AMQP version negotiation.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <!-- Channel Delegation -->
+
+ <xs:element name="DelegationChannel" substitutionGroup="cppa:Channel"
+ type="cppa:DelegationChannelType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#DelegationChannel">DelegationChannel</a> element
+ supports the <em>delegation</em> of message processing by parties to third parties that act
+ on their behalf. The element MAY be used in
+ a <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a>.
+ </p>
+ <p>The legal meaning and implicationsof the use of messaging delegation are out of scope for this
+ specification. </p>
+ <p>If a <a href="#DelegationChannel">DelegationChannel</a> is used in a <a href="#CPP">CPP</a>, that
+ <a href="#CPP">CPP</a> is called the delegation <em>source</em> <a href="#CPP">CPP</a>.
+ A <a href="#DelegationChannel">DelegationChannel</a> in a source
+ <a href="#CPP">CPP</a> MUST specify a target
+ a <a href="#PartyId">PartyId</a>. It MAY also target a specific <a href="#ProfileIdentifier">ProfileIdentifier</a> that identifies a specific
+ <a href="#CPP">CPP</a> for the Party identified using <a href="#PartyId">PartyId</a>.
+
+ The <a href="#CPP">CPP</a> for the target <a href="#PartyId">PartyId</a> is
+ the delegation target <a href="#CPP">CPP</a>.
+
+ If a <a href="#ProfileIdentifier">ProfileIdentifier</a> is not explicitly
+ specified in the source <a href="#CPP">CPP</a>, the reference target <a href="#CPP">CPP</a>
+ MAY available as contextual information.
+ Mechanisms for making that contextual
+ information available to CPPA3 processing are out of scope for this specification.
+ Note that any reference is unambiguous if there is only one known
+ <a href="#CPP">CPP</a> for the target <a href="#PartyId">PartyId</a>.
+ Criteria for handling ambiguity, if there are multiple <a href="#CPP">CPP</a>s for the
+ target <a href="#PartyId">PartyId</a>, are out of scope for this specification.
+ </p>
+ <p>If, in a source
+ <a href="#CPP">CPP</a> for
+ a Party P1, there is an
+ <a href="#ActionBinding">ActionBinding</a>
+ that binds an <em>Action</em> in a <a href="#ServiceBinding">ServiceBinding</a> to a
+ target <a href="#CPP">CPP</a> for a Party P3, then that
+ target <a href="#CPP">CPP</a> MUST define an <a href="#ActionBinding">ActionBinding</a>
+ that has the same value for
+ <em>name</em> and <em>sendOrReceive</em>
+ in a <a href="#ServiceBinding">ServiceBinding</a> that has the same value for
+ the <a href="#Service">Service</a>
+ element as the source <a href="#Service">Service</a>. The values for any ebBP attributes in
+ the source and CPPs MUST also match. The source CPP is invalid if these requirements is not met.
+ </p>
+ <p>In a valid source <a href="#CPP">CPP</a> for a Party P1, a
+ <a href="#DelegationChannel">DelegationChannel</a> element targeting a <a href="#CPP">CPP</a> for a Party P3
+ expresses that P3 MAY act as delegated Sender (if the value
+ of the <em>sendOrReceive</em> attribute of the <a href="#ActionBinding">ActionBinding</a>
+ is <em>send</em>) or Receiver (if the value is <em>receive</em>) for the P1 action.
+ Note that an <a href="#ActionBinding">ActionBinding</a> in
+ the target <a href="#CPP">CPP</a> MAY provide more than one alternative <a href="#Channel">Channel</a>
+ for the action. The delegation feature decouples the channel binding for the
+ target <a href="#PartyId">PartyId</a>
+ from the delegating Party.
+ </p>
+
+ <p>As CPPA3 <a href="#Channel">Channel</a>s are bound to individual actions in services using
+ <a href="#ActionBinding">ActionBinding</a>s,
+ Parties MAY use delegation channels for some communication but not for others. For example, a
+ Party MAY outsource
+ a specific <a href="#Service">Service</a> to a particular service provider that operates its own
+ messaging endpoint, distinct and separate from Party's endpoint. The Party
+ MAY outsource other <a href="#Service">Service</a>s to other Parties and operate its own
+ messaging endpoint for other communication.
+ </p>
+
+ <p>In a <a href="#CPA">CPA</a>, a <a href="#DelegationChannel">DelegationChannel</a> MUST include
+ a <a href="#PartyId">PartyId</a> or a <a href="#CounterPartyId">CounterPartyId</a> element.
+
+ A
+ <a href="#PartyId">PartyId</a> expresses a delegation from the Party identified in the
+ <a href="#PartyInfo">PartyInfo</a> element. If followed by a
+ <a href="#ProfileIdentifier">ProfileIdentifier</a> element, this element identifies a
+ <a href="#CPP">CPP</a> for the referenced <a href="#PartyId">PartyId</a>.
+
+ A <a href="#PartyId">CounterPartyId</a> expresses a delegation from the Party identified in the
+ <a href="#CounterPartyInfo">CounterPartyInfo</a> element. If followed by a
+ <a href="#ProfileIdentifier">ProfileIdentifier</a> element, this element identifies a
+ a <a href="#CPP">CPP</a> for the referenced <a href="#CounterPartyId">CounterPartyId</a>.
+
+ A <a href="#DelegationChannel">DelegationChannel</a> in a
+ <a href="#CPA">CPA</a> MAY include both a <a href="#PartyId">PartyId</a> and a
+ <a href="#CounterPartyId">CounterPartyId</a> element. This expresses delegations from both Parties in
+ the <a href="#CPA">CPA</a>. Note that it is possible that both Parties delegate to the
+ same third Party.
+ </p>
+ <p>
+ When using <em>delegation</em>, the delegated Party acts as Sender or Receiver for
+ messages for the delegating Party using its own identifier.
+ This is different from <em>impersonation</em>, where the third party uses the impersonated Party's
+ identifier.
+ The difference can be seen when used with protocols like ebMS2,
+ ebMS3 and EDIINT:</p>
+ <ul>
+ <li>In case of <em>delegation</em>, the third party that acts
+ as Sender or Receiver is identified in the message headers identifying Sender or Receiver party.
+ The third party uses its own X.509 or other security tokens to secure communication.</li>
+ <li>In case of <em>impersonation</em>, the third party is anonymous or even not noticeable.
+ Its messaging software processes messages using the impersonated Party's identifier and
+ MAY even use a security token linked to the impersonated Party. </li>
+ </ul>
+ <p>If third Parties exchange messages on behalf of other Parties, the relation of those messages to the
+ Parties on whose behalf the third party operate is to be encoded in different ways, e.g. at the
+ payload content level (for example using the UN/CEFACT Standard Business Document Header [SBDH])
+ or (for protocols that support it, like ebMS3 and AS4), using message properties.
+ </p>
+ <p>The CPPA3 delegation features supports <em>authorization</em> and <em>routing</em>:</p>
+ <ul>
+ <li>A Party P2 that receives messages from a third Party P3 that suggests it acts on behalf of another
+ Party P1
+ SHOULD use delegation information in relevant <a href="#CPP">CPP</a>s or <a href="#CPA">CPA</a>s as
+ information to determine whether this P3 is in fact <em>authorized</em> to send on
+ behalf of P1.</li>
+ <li>A Party P1 that intends to sends data to a Party P2 SHOULD use the delegation information
+ in relevant <a href="#CPP">CPP</a>s or <a href="#CPA">CPA</a>s to determine if the message
+ is instead expected to be sent to a third Party P3 that P2 delegates messaging receiving to.</li>
+ </ul>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="DelegationChannelType">
+ <xs:complexContent>
+ <xs:extension base="cppa:ChannelType">
+ <xs:sequence>
+ <xs:sequence minOccurs="0">
+ <xs:element ref="cppa:PartyId"/>
+ <xs:element ref="cppa:ProfileIdentifier" minOccurs="0"/>
+ </xs:sequence>
+ <xs:sequence minOccurs="0">
+ <xs:element ref="cppa:CounterPartyId"/>
+ <xs:element ref="cppa:ProfileIdentifier" minOccurs="0"/>
+ </xs:sequence>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="CounterPartyId" type="cppa:PartyIdType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A <a href="#CounterPartyId">CounterPartyId</a> element MAY be used in a <a href="#DelegationChannel">DelegationChannel</a> in a <a href="#CPA">CPA</a>.
+ It identifies the third Party to which the Party identified in the
+ <a href="#CounterPartyInfo">CounterPartyInfo</a> element delegates message processing. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Transport -->
+
+ <xs:element name="Transport" type="cppa:TransportType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An abstract element to configure a transport.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="TransportType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This is an abstract type that can be substituted to cover particular transport protocols. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="required"/>
+ </xs:complexType>
+
+ <xs:element name="TCPTransport" type="cppa:TCPTransportType" substitutionGroup="cppa:Transport"
+ abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An abstract element to represent transport protocols based on
+ Transmission Control Protocol (TCP), such as HTTP, SMTP and FTP.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="TCPTransportType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An abstract type to represent configuration information
+ common to TCP-based transport protocols.</p>
+ <p>If the attribute <em>supportsIPv4</em> is present with a false value, then the
+ elements <a href="#ClientIPv4">ClientIPv4</a> and
+ <a href="#ServerIPv4">ServerIPv4</a> MUST NOT be present.
+ </p>
+ <p>If the attribute <em>supportsIPv6</em> is present with a false value, then the
+ elements <a href="#ClientIPv6">ClientIPv6</a> and
+ <a href="#ServerIPv6">ServerIPv6</a> MUST NOT be present.
+ </p>
+ <p>If the server supports IPv4, and DNS is used for endpoint resolution,
+ then any domains named in the
+ <a href="#Endpoint">Endpoint</a> element MUST be discoverable using
+ DNS A records.</p>
+ <p>If the server supports IPv6, and DNS is used for endpoint resolution,
+ then any domains named in the
+ <a href="#Endpoint">Endpoint</a> element MUST be discoverable using
+ DNS AAAA records.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:TransportType">
+ <xs:sequence>
+ <xs:element ref="cppa:ClientIPv4" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ClientIPv6" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ServerIPv4" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ServerIPv6" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Endpoint" minOccurs="0"/>
+ <xs:element ref="cppa:TransportLayerSecurity" minOccurs="0"/>
+ <xs:element ref="cppa:UserAuthentication" minOccurs="0"/>
+ <xs:element ref="cppa:TransportRestart" minOccurs="0"/>
+ <xs:any namespace="##other" processContents="lax" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="supportsIPv4" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Indicates support for IPv4. Its absence is equivalent to presence with a true value.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="supportsIPv6" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Indicates support for IPv6. Its absence is equivalent to presence with a true value.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="HTTPTransport" substitutionGroup="cppa:TCPTransport">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a transport using the Hypertext Transfer Protocol (HTTP)
+ application protocol. It covers both HTTP 1.1 [RFC7230] and HTTP/2 [RFC7540].</p>
+ <p>Note that HTTP/2 enables using a single origin connection for any server.
+ This means that exchanges using <a href="#Channel">Channel</a>s that are bound to
+ HTTP/2 transports SHOULD initiate new <em>streams</em>s on the existing HTTP/2
+ connection, if such an existing connection is available.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:TCPTransportType">
+ <xs:sequence>
+ <xs:element name="HTTPVersion" minOccurs="0" maxOccurs="unbounded">
+ <xs:simpleType>
+ <xs:union>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="1.1"/>
+ <xs:enumeration value="2.0"/>
+ </xs:restriction>
+ </xs:simpleType>
+ <xs:simpleType>
+ <xs:annotation>
+ <xs:documentation>Escape for use with any future
+ post 2.0 protocol.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:minLength value="1"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:union>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element ref="cppa:ChunkedTransferCoding" minOccurs="0"/>
+ <xs:element ref="cppa:ContentCoding" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Pipelining" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="method" default="POST">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="POST"/>
+ <xs:enumeration value="GET"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:attribute>
+ </xs:extension>
+
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ChunkedTransferCoding" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specificies if <em>chunked</em> Transfer Coding is
+ used for the transport.
+ Chunking is an HTTP 1.1 feature, specified in [RFC7230], section 4.1.
+ It MUST NOT be used when configuring an HTTP 2.0 transport [RFC7540].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ContentCoding" type="xs:token">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a Content Coding that MAY be used for the transport. </p>
+ <p>The content of the element MUST be a valid Content Coding parameter, the values of
+ which are specified in the IANA Content Coding Registry [IANA-HTTP].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Pipelining" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specificies use of an HTTP 1.1 feature in which multiple requests using the
+ transpors MAY be pipelined. The element MUST NOT be used with HTTP/2.
+ </p>
+ <p>Absence of the element is equivalent to it being present with a <em>false</em> value.</p>
+ <p>Of the messaging protocols covered in this version of CPPA3, only [EBMS3PART2], sections 6.3.1 and
+ 6.3.2, specifies a use of HTTP pipelining.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="SMTPTransport" substitutionGroup="cppa:TCPTransport">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#SMTPTransport">SMTPTransport</a> element defines a transport using the (SMTP)
+ application protocol [RFC5321]. It
+ can be used with e.g. ebMS2, ebMS3 (but not AS4) or for AS1.</p>
+ <p>Additional configuration elements for SMTP are the following:</p>
+ <ol>
+ <li>The <em>From</em> element can be used to configure a value for the
+ SMTP <em>From</em> header.</li>
+ <li>The <em>To</em> element can be used to configure a value for
+ the SMTP <em>To</em> header.</li>
+ <li>The <em>Subject</em> element can be used to configure a value for
+ the SMTP <em>Subject</em> header.</li>
+ </ol>
+ <p>When using SMTP, transport data is restricted to 7bit US-ASCII with lines no longer than
+ 1000 characters including any trailing CRLF line separator, the encoding rules of section 6
+ of RFC 2045 apply, meaning application of appropriate <em>content-transfer-encoding</em>. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:TCPTransportType">
+ <xs:sequence>
+ <xs:element name="From" type="cppa:non-empty-string" minOccurs="0"/>
+ <xs:element name="To" type="cppa:non-empty-string" minOccurs="0"/>
+ <xs:element name="Subject" type="cppa:non-empty-string" minOccurs="0"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="FTPTransport" substitutionGroup="cppa:TCPTransport">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Transport using the File Transfer Protocol [RFC0959].</p>
+ <p>The <em>method</em> attribute MAY be set to either <em>PUT</em> or <em>GET</em>,
+ correspondonding to sender-initiated or receiver-oriented transfer,
+ respectively, and reflecting the FTP command to be used.
+ Absence of the attribute is equivalent to presence with the
+ value <em>PUT</em>.
+ </p>
+ <p>When used with <em>PUT</em> transfer, the <em>receiver</em> party is
+ expected to provide the server-related sub-elements. When used with <em>GET</em>,
+ these elements are expected to be provided by the sender.
+ </p>
+ <p>To specify use of TLS, users MUST provide a <a
+ href="#TransportLayerSecurity">TransportLayerSecurity</a> subelement.
+ The reason is that no
+ official IANA <em>ftps</em> scheme exists, unlike <em>https</em> which refers to
+ TLS-secured HTTP. In practice, many networking software implementations
+ understand the <em>ftps</em> URI scheme as referring to TLS-secured file
+ transfer.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:TCPTransportType">
+ <xs:attribute name="method" default="PUT">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="PUT"/>
+ <xs:enumeration value="GET"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SFTPTransport" substitutionGroup="cppa:TCPTransport">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Transport using the SSH File Transfer Protocol (SFTP) subsystem of the
+ Secure Shell (SSH) Connection Protocol [RFC4254]. As for the
+ <a href="#FTPTransport">FTPTransport</a>, the <em>method</em>
+ attribute can be used to indicate the direction of transfer and the
+ commands to be used.
+ </p>
+ <p>This transport MUST not be used with a <a
+ href="#TransportLayerSecurity">TransportLayerSecurity</a> subelement,
+ as SSH2 provides security natively.
+ </p>
+ <p>To configure use of compression, a <a href="#Compression">Compression</a>
+ element MUST be provided. The only algorithm currently supported in SSH2
+ is <em>application/gzip</em>.
+ </p>
+ <p>To specify use of particular SSH public keys, a <a href="#SSHClientKeyRef">SSHClientKeyRef</a> (for
+ client authentication) or a <a href="#SSHServerKeyRef">SSHServerKeyRef</a> (for server
+ authentication) MUST be used.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:TCPTransportType">
+ <xs:sequence>
+ <xs:element ref="cppa:Compression" minOccurs="0"/>
+ <xs:element ref="cppa:SSHClientKeyRef" minOccurs="0" />
+ <xs:element ref="cppa:SSHServerKeyRef" minOccurs="0" />
+ <xs:element ref="cppa:EncryptionAlgorithm" minOccurs="0" maxOccurs="unbounded" />
+ <xs:element ref="cppa:SSHCipher" minOccurs="0" maxOccurs="unbounded" />
+ </xs:sequence>
+ <xs:attribute name="method" default="PUT">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="PUT"/>
+ <xs:enumeration value="GET"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:attribute>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SSHCipher" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An SSH cipher that MAY be used for the SSH connection using the
+ notation used in the SSH specifications. For example,
+ <em>aes256-gcm@openssh.com</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <xs:element name="WSTransport" substitutionGroup="cppa:TCPTransport">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Transport using the Web Socket Protocol [RFC6455].
+ Since Web Socket is a bidirectional protocol, either sender or
+ receiver can provide the initial endpoint to be used to set up
+ the Web Socket Transport between two parties. Note that
+ Web Socket connections are persistent and can be reused for
+ multiple transfers, in either direction.
+ </p>
+ <p>To specify use of TLS, users MUST provide a <a href="#TransportLayerSecurity">TransportLayerSecurity</a> subelement,
+ and use the <em>wss</em> scheme in the endpoint
+ address.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:complexContent>
+ <xs:extension base="cppa:TCPTransportType">
+ <xs:sequence>
+ <xs:element name="SubProtocol" type="cppa:non-empty-string" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="AMQPTransport" substitutionGroup="cppa:TCPTransport"
+ type="cppa:AMQPTransportType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Transport using the native TCP transport mode defined in the
+ AMQP Transport protocol [amqp-core-transport-v1.0].
+ </p>
+ <p>In a <a href="#CPP">CPP</a>,
+ if an <a href="#ActionBinding">ActionBinding</a> binds an sending action in a service
+ to an <a href="#AMQPChannel">AMQPChannel</a> that uses an
+ <a href="#AMQPTransport">AMQPTransport</a>, then the AMQP transport is a potential AMQP link
+ <em>source</em>
+ for the party. If the binding is of a receiving action, then the channel is a potential
+ AMQP link <em>target</em> for the party.</p>
+ <p>In a <a href="#CPA">CPA</a>, an <a href="#ActionBinding">ActionBinding</a> that is bound to
+ an <a href="#AMQPChannel">AMQPChannel</a> that uses an
+ <a href="#AMQPTransport">AMQPTransport</a> configures a link to be used to
+ exchange data using AMQP messaging from the sender party as link <em>source</em> to the receiver party
+ as link <em>target</em>.
+ </p>
+ <p>In AMQP, links are named so that they can be recovered when communication is interrupted.
+ AMQP link names MUST uniquely identify the link amongst all links of the same direction between the
+ two participating containers.
+ It is RECOMMENDED to adopt a consistent naming convention for link names.
+ As an <a href="#AgreementIdentifier">AgreementIdentifier</a> value is
+ unique and shared between two parties, and the value of the <em>id</em> attribute
+ of an <a href="#ActionBinding">ActionBinding</a>
+ element is unique within a CPA, it is RECOMMENDED to use the concatenation of these two
+ values, using the <em>#</em> character as separator, to name the AMQP link.
+ </p>
+ <p>In AMQP, links are attached to sessions, which begin on channels on connections..
+ Full specification of
+ the details of the mapping of CPPA3 elements to these AMQP constructs
+ is out of scope for this specification. However, it is RECOMMENDED that
+ <a href="#ActionBinding">ActionBinding</a>s in a <a href="#CPA">CPA</a> that use the same <a href="#AMQPChannel">AMQPChannel</a> reuse a single AMQP session.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <xs:complexType name="AMQPTransportType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>To specify use of TLS as a pure TLS tunnel through which the standard AMQP protocol flows,
+ users MUST provide a <a href="#TransportLayerSecurity">TransportLayerSecurity</a> subelement. This is called
+ the <em>alternative establishment</em> in section 5.2.1 of [amqp-core-transport-v1.0].
+ </p>
+ <p>In a <a href="#CPP">CPP</a>, one or multiple <a href="#SenderSettleMode">SenderSettleMode</a>
+ and one or <a href="#ReceiverSettleMode">ReceiverSettleMode</a> elements MAY be present.
+ These elements encode the sender or receiver settle modes that the AMQP transport MAY
+ deploy. In a <a href="#CPA">CPA</a>, at most one of either type of elements MAY be
+ present, reflecting the mode that the transport MUST deploy. Absence of any of the
+ two elements means the default specified in [amqp-core-transport-v1.0] apply.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:TCPTransportType">
+ <xs:sequence>
+ <!-- connection configuration -->
+ <xs:element ref="cppa:MaxFrameSize" minOccurs="0"/>
+ <xs:element ref="cppa:ChannelMax" minOccurs="0"/>
+ <xs:element ref="cppa:IdleTimeOut" minOccurs="0"/>
+ <xs:element ref="cppa:ConnectionProperties" minOccurs="0"/>
+ <!-- session configuration -->
+ <xs:element ref="cppa:SessionProperties" minOccurs="0"/>
+ <!-- link configuration -->
+ <xs:element ref="cppa:SenderSettleMode" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ReceiverSettleMode" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:LinkProperties" minOccurs="0"/>
+ <!-- security configuration -->
+ <xs:element ref="cppa:AMQPSecurity" minOccurs="0"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="AMQPSecurity">
+ <xs:annotation>
+ <xs:documentation>
+ <p>AMQP messaging is secured using Simple Authentication and Security Layer (SASL) mechanism
+ [RFC4422]. AMQP clients and servers negotiate a security mechanism in the SASL handshake.
+ CPPA3 allows parties to express and negotiate supported mechanisms. As with TLS, CPPA3
+ negotiation does not replace the protocol handshaking. Rather, it provides an ahead of time
+ compatibility check.
+ </p>
+ <p>If the sending peer does not require its partner to authenticate with it, then
+ it SHOULD send a list of one element with its value as the SASL mechanism <em>ANONYMOUS</em>.</p>
+ <p>To specify the use of TLSs as an in-place upgrade, in which case the transition to TLS occurs
+ after the AMQP protocol handshake, users MUST provide a <a href="#TransportLayerSecurity">TransportLayerSecurity</a> subelement. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="SASLMechanism" type="cppa:non-empty-string" minOccurs="1"
+ maxOccurs="unbounded"/>
+ <xs:element ref="cppa:TransportLayerSecurity" minOccurs="0" maxOccurs="1"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="MaxFrameSize" type="xs:positiveInteger">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>max-frame-size</em> parameter as defined in
+ section 2.7.1 of [amqp-core-transport-v1.0] expresses a proposed maximum frame size</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ChannelMax" type="xs:positiveInteger">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>channel-max</em> parameter as defined in
+ section 2.7.1 of [amqp-core-transport-v1.0] expresses the maximum channel number that
+ can be used on the connection</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="IdleTimeOut" type="xs:positiveInteger">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>idle-time-out</em> parameter as defined in
+ section 2.7.1 of [amqp-core-transport-v1.0] expresses the maximum channel number that can
+ be used on the connection</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ConnectionProperties" type="cppa:PropertySetType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>ConnectionProperties</em> element allows configuration of
+ connection properties as defined in section 2.7.1 of [amqp-core-transport-v1.0].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <xs:element name="SessionProperties" type="cppa:PropertySetType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>SessionProperties</em> element allows configuration of
+ connection properties as defined in section 2.7.2 of [amqp-core-transport-v1.0].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+
+ </xs:element>
+
+ <xs:element name="SenderSettleMode">
+ <xs:annotation>
+ <xs:documentation>Sender Settle Mode as defined in 2.8.2 of [amqp-core-transport-v1.0]</xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:string">
+ <xs:enumeration value="unsettled"/>
+ <xs:enumeration value="settled"/>
+ <xs:enumeration value="mixed"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+
+ <xs:element name="ReceiverSettleMode">
+ <xs:annotation>
+ <xs:documentation>Receiver Settle Mode as defined in 2.8.3 of [amqp-core-transport-v1.0]</xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:string">
+ <xs:enumeration value="first"/>
+ <xs:enumeration value="second"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+
+ <xs:element name="LinkProperties" type="cppa:PropertySetType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>LinkProperties</em> element allows configuration of
+ connection properties as defined in section 2.7.3 of [amqp-core-transport-v1.0].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <!-- Networking -->
+
+ <xs:element name="ClientIPv4">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines an IP address (belonging to the IPv4 address family)
+ or address range which the client MAY use for the transport.</p>
+ <p>An address range can be specified using common notations such as
+ the <em>*</em> wildcard character, the <em>-</em> separator and the CIDR
+ <em>/n</em> syntax to select the number of matching bits.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string"/>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="ClientIPv6">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines an IPv6 address literal or address range
+ which the client MAY use for the transport.</p>
+ <p>An address range can be specified using common notations such as
+ the <em>*</em> wildcard character, the <em>-</em> separator and the CIDR
+ <em>/n</em> syntax to select the number of matching bits.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string"/>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ServerIPv4">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines an IP address (belonging to the IPv4 address family) which
+ the server MAY use for the transport.
+ If present, when using IPv4 and DNS, an Internet name used in the <a href="#Endpoint">Endpoint</a>
+ MUST be published as a DNS A record.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string"/>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ServerIPv6">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element defines an IPv6 address literal which the server MAY use for the transport.
+ If present, when using IPv6 and DNS, an Internet name used in the <a href="#Endpoint">Endpoint</a>
+ MUST be published as a DNS AAAA record.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string"/>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="Endpoint" type="xs:anyURI">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a URI value that MUST be used as endpoint address.</p>
+ <p>In ebMS3, this corresponds to the <em>PMode[1].Protocol.Address</em> parameter.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- TLS -->
+
+ <xs:element name="TransportLayerSecurity">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This elements specifies use of configuration for Transport Layer Security. Note that, while
+ some URI schemes like <em>https</em> already imply use of a TLS protocol, this is
+ not the case for other schemes, such as <em>ftp</em>. Therefore, the element is
+ REQUIRED in all situations where use of TLS is expected. Subelements of the
+ element can be used to further configure how the TLS protocol is used.
+ </p>
+ <p>If one or more <a href="#ClientCertificatePolicySetRef">ClientCertificatePolicySetRef</a> elements
+ is present, Policy Certification Authority certificates and the issuing Certificate Authority
+ certificate in the client certificate chain MUST contain a <em>certificatePolicies</em>
+ X.509 extension, the values of which MUST be within the set of referenced policies.
+ </p>
+ <p>If one or more <a href="#ServerCertificatePolicySetRef">ServerCertificatePolicySetRef</a> elements
+ is present, Policy Certification Authority certificates and the issuing Certificate Authority
+ certificate in the server certificate chain MUST contain a <em>certificatePolicies</em>
+ X.509 extension, the values of which MUST be within the set of referenced policies.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:StartTLS" minOccurs="0" maxOccurs="1"/>
+ <xs:element ref="cppa:TLSProtocol" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ServerNameIndicationRequired" minOccurs="0" maxOccurs="1"/>
+ <xs:element ref="cppa:CipherSuite" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ClientCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:ClientCertificateRequired" minOccurs="0"/>
+ <xs:element ref="cppa:ClientTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:ClientCertificatePolicySetRef" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ServerCertificateRef" minOccurs="0"/>
+ <xs:element ref="cppa:ServerCertificateRequired" minOccurs="0"/>
+ <xs:element ref="cppa:ServerTrustAnchorSetRef" minOccurs="0"/>
+ <xs:element ref="cppa:ServerCertificatePolicySetRef" minOccurs="0"
+ maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="StartTLS" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element can be used to indicate the ability to use an extension to use
+ of plain text communication protocols, which offers a way to upgrade a plain text
+ connection to an encrypted TLS connection instead of using a separate port for
+ encrypted communication. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="TLSProtocol">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The element configures the protocol to be used for
+ <a href="#TransportLayerSecurity">TransportLayerSecurity</a>.
+ </p>
+ <p>If not present, this element is to be interpreted as being present
+ with the value <em>TLS</em>.</p>
+ <p>When used with secure <a href="Transport">Transport</a> elements used for
+ <a href="#ebMS3Channel">ebMS3Channel</a> elements, this element corresponds to
+ the <em>Pmode[1].Protocol.Security.Protocol</em>
+ parameter defined in ebMS3 Part 2 and
+ the attribute <em>version</em> corresponds to the
+ <em>Pmode[1].Protocol.Security.ProtocolVersion</em> parameter.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:TLSProtocolType">
+ <xs:attribute name="version" type="cppa:TLSProtocolVersionType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute defines the version of the Transport Layer Security protocol.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:simpleType name="TLSProtocolType">
+ <xs:annotation>
+ <xs:documentation>At the time of writing, for security reasons, SSL 2.0 and 3.0
+ MUST NOT be used.</xs:documentation>
+ </xs:annotation>
+ <xs:union>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="TLS"/>
+ </xs:restriction>
+ </xs:simpleType>
+ <xs:simpleType>
+ <xs:annotation>
+ <xs:documentation>Escape for use with any future post TLS protocol.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:minLength value="1"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:union>
+ </xs:simpleType>
+
+ <xs:simpleType name="TLSProtocolVersionType">
+ <xs:annotation>
+ <xs:documentation>At the time of writing, for security reasons, TLS 1.0 and 1.1
+ SHOULD NOT be used.</xs:documentation>
+ </xs:annotation>
+ <xs:union>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="1.0"/>
+ <xs:enumeration value="1.1"/>
+ <xs:enumeration value="1.2"/>
+ <xs:enumeration value="1.3"/>
+ </xs:restriction>
+ </xs:simpleType>
+ <xs:simpleType>
+ <xs:annotation>
+ <xs:documentation>Escape for use with any future post 1.3 TLS version.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:minLength value="1"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:union>
+ </xs:simpleType>
+
+ <xs:element name="ServerNameIndicationRequired" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element can be used by the server to indicate that the client MUST
+ implement the TLS Server Name Indication feature [RFC6066]. This would be
+ the case if the server hosts multiple 'virtual' servers at a single
+ underlying network address and needs to know which one the client intends
+ to connect to.
+ </p>
+ <p>Note that this feature is only available in TLS version from TLS 1.2.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+
+
+ <xs:element name="CipherSuite" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A TLS cipher suite that may be used for the TLS connection using the
+ alphanumeric notation used in the TLS specifications. For example,
+ <em>TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256</em>.
+ </p>
+ <p>In ebMS3 Part 2, a corresponding parameter called
+ <em>Pmode[1].Protocol.Security.SecurityAlgorithm</em> is defined.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ClientCertificateRef" type="cppa:CertificateRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a leaf certificate that MUST be used for TLS client authentication.</p>
+ <p>In ebMS3 Part 2, a corresponding parameter called
+ <em>Pmode[1].Protocol.Security.Client.Certificate</em> is defined</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ClientCertificateRequired" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>In a CPP, this element can be used in a
+ <a href="#TransportLayerSecurity">TransportLayerSecurity</a> element by a server party
+ to indicate whether a leaf
+ signing certificate is to be provided by the client party in the
+ corresponding element in its CPP. If present with a true value in a CPP context for a
+ receiver channel, a valid <a href="#ClientCertificateRef">ClientCertificateRef</a> element
+ MUST be present in the CPP of the sending party for the channel. This referenced
+ certificate MUST be included for specified CPA transport in a CPA derived from these
+ CPPs. Client authentication is REQUIRED to use the agreed transport.
+ </p>
+ <p>This element MUST NOT be used in a CPA. If specified in a CPP for the
+ clien party for the transport, its value is ignored in unification.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+
+ <xs:element name="ClientTrustAnchorSetRef" type="cppa:CertificateRefType"
+ substitutionGroup="cppa:CertificateRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a trust anchor containing a set of Certificate Authorities
+ that a client certificate MUST chain to.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ClientCertificatePolicySetRef" type="cppa:CertificatePolicySetReferenceType">
+ <xs:annotation>
+ <xs:documentation>A reference to an X.509 certificate policy set to be used for a
+ client certificate.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <xs:element name="ServerCertificateRef" type="cppa:CertificateRefType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a leaf certificate that MUST used for TLS server authentication.</p>
+ <p>In ebMS3 Part 2, a corresponding parameter called
+ <em>Pmode[1].Protocol.Security.Server.Certificate</em> is defined</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ServerCertificateRequired" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>
+ <p>In a CPP, this element can be used in a
+ <a href="#TransportLayerSecurity">TransportLayerSecurity</a> element by a client party
+ to indicate whether a leaf
+ signing certificate is to be provided by the server party in the
+ corresponding element in its CPP. If present with a true value in a CPP context for a
+ receiver channel, a valid <a href="#ServerCertificateRef">ServerCertificateRef</a> element
+ MUST be present in the CPP of the server party for the channel. This referenced
+ certificate MUST be included for specified CPA transport in a CPA derived from these
+ CPPs. Server authentication is REQUIRED to use the agreed transport.
+ </p>
+ <p>This element MUST NOT be used in a CPA. If specified in a CPP for the
+ clien party for the transport, its value is ignored in unification.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+
+ <xs:element name="ServerTrustAnchorSetRef" type="cppa:CertificateRefType"
+ substitutionGroup="cppa:CertificateRef">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A reference to a trust anchor containing a set of Certificate Authorities
+ that a server certificate MUST chain to.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="ServerCertificatePolicySetRef" type="cppa:CertificatePolicySetReferenceType">
+ <xs:annotation>
+ <xs:documentation>A reference to an X.509 certificate policy set to be used for a
+ server certificate.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="TransportRestart">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#TransportRestart">TransportRestart</a> element specifies and configures
+ the use of a restart protocol.
+ A restart transport protocol allows clients to check if previous partial transmissions exist and
+ (if so) resume from the last known position in the data stream. </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:RestartProtocol"/>
+ <xs:element ref="cppa:RestartInterval" minOccurs="0"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="RestartProtocol" type="xs:token">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a specific sub-protocol for transport protocol restarts.
+ </p>
+ <p>The value <em>AS2-Restart</em> identifies the protocol specified in [as2-restart].
+ Since this protocol is specific to HTTP, it MUST NOT be used with transports
+ other than <a href="#HTTPTransport">HTTPTransport</a>.
+ Since it depends on some AS2-specific features, it SHOULD NOT be used with HTTP
+ transports not bound to
+ an <a href="#AS2Channel">AS2Channel</a>.
+ </p>
+ <p>This element corresponds to the <em>Pmode[1].Protocol.Restart.Protocol</em> P-Mode
+ parameter defined in
+ [EBMS3PART2]. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="RestartInterval" type="xs:duration">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies the expresses the maximum amount of
+ time the recipient of a message SHOULD cache a temporary incomplete copy of the
+ message, for a particular message transfer. </p>
+ <p>This element corresponds to the <em>Pmode[1].Protocol.Restart.Interval</em> P-Mode
+ parameter defined in
+ [EBMS3PART2]. </p>
+ <p>This element MAY be specified in a <a href="#CPP">CPP</a> for a Receiver transport.
+ It SHOULD NOT be set for a Sender transport.
+ In <a href="#CPA">CPA</a> formation, the value to be included in the
+ <a href="#CPA">CPA</a> is the Receiver value, if present.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Properties -->
+
+ <xs:element name="Property">
+ <xs:annotation>
+ <xs:documentation>
+ <p>In some messaging protocols including ebMS3, messages and payload parts can carry
+ arbitrary named properties, with values constrained to be simple values.
+ </p>
+ <p>In ebMS3, a message property can be configured as an
+ item on the <em>PMode[1].BusinessInfo.Properties</em> list.
+ </p>
+ <p>The property <em>CompressionType</em> MUST NOT be set for AS4 as it is reserved for use
+ by the AS4 compression feature (see issue
+ https://issues.oasis-open.org/browse/EBXMLMSG-75).
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="name" use="required" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The name of the property.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="type" type="xs:anyURI"/>
+ <xs:attribute name="value" use="optional" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>The value of the property, if the property has a fixed value.
+ Note that this functionality is not mentioned in D.3.3 of [EBMS3CORE].</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="minOccurs" type="xs:nonNegativeInteger">
+ <xs:annotation>
+ <xs:documentation>The minimum occurrence of the property.
+ In ebMS3, the allowed values are 0 or 1.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="maxOccurs" type="cppa:maxoccurstype">
+ <xs:annotation>
+ <xs:documentation>The maximum occurrence of the property.
+ In ebMS3, the allowed value is 1.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="PropertySet" type="cppa:PropertySetType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#PropertySet">PropertySet</a> element defines a set of
+ <a href="#Property">Property</a> elements. It supports
+ definitions of property sets that are reusable. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="PropertySetType">
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:Property" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID" use="optional">
+ <xs:annotation>
+ <xs:documentation>An XML identifier, allowing property definitions to be referenced
+ within the XML document.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <!-- Payload Profile -->
+
+ <xs:element name="PayloadProfile">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#PayloadProfile">PayloadProfile</a> element provides the logical definition of the
+ expected message content as one or multiple payload parts. The complementary
+ <a href="#Packaging">Packaging</a> element provides a mapping to physical packaging constructs.
+ This mapping is done by shared values of <em>PayloadPart/PartName</em> elements and
+ <em>PayloadPart</em> attributes on <em>Packaging</em> elements.
+ </p>
+ <p>The <a href="#PayloadProfile">PayloadProfile</a> elements implements the ebMS3 concept of
+ payload profiles. When used with ebMS3, the mapping to ebMS3 PMode parameters is as
+ follows:</p>
+ <ol>
+ <li>The sequence of <a href="#PayloadPart">PayloadPart</a> elements maps to the
+ <em>PMode[1].BusinessInfo.PayloadProfile[]</em> P-Mode
+ parameter list.</li>
+ </ol>
+ <p>However, CPPA3 uses <a href="#PayloadProfile">PayloadProfile</a> as a general concept, and
+ does not limit its use to ebMS3 channels. </p>
+ <p>Payload part definitions are referenced. Multiple payload profiles may reuse payload
+ part definitions.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:PayloadPart" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID"/>
+ </xs:complexType>
+ </xs:element>
+
+
+ <xs:element name="PayloadPart">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#PayloadPart">PayloadPart</a> element provides a logical definition of
+ a payload part. A <a href="#PayloadPart">PayloadPart</a> MAY be referenced from
+ a <a href="#PayloadProfile">PayloadProfile</a> and from a
+ <a href="#Packaging">Packaging</a> element.</p>
+ <p>A <a href="#PayloadPart">PayloadPart</a> MAY be signed at payload-level.
+ A <a href="#Signature">Signature</a> element MAY be provided to record any relevant
+ constraints on payload signatures, such as constraints on certificates or algorithms
+ to be used.
+ Note that processing such signatures is not functionality of the <a href="#Channel">Channel</a> and does not
+ have to be provided by the Message Service handling that channel, but by business
+ applications or other components that produce or consume payloads.
+ </p>
+ <p>Similarly, a <a href="#PayloadPart">PayloadPart</a> MAY be encrypted at payload-level.
+ If this is the case,
+ an <a href="#Encryption">Encryption</a> element MAY be provided to provide any relevant
+ constraints. As with payload signing, this encryption is not functionality of
+ the <a href="#Channel">Channel</a> and the responsible Message Service Handler.
+ </p>
+ <p>Presence of the <a href="#Signature">Signature</a> and <a href="#Encryption">Encryption</a> element defines constraints on,
+ respectively, signing and encryption. Absence of these elements specifies that no
+ constraints are set. Whether payload level signing and encryption is required can be
+ expressed using the <em>requireSignature</em> <em>requireEncryption</em> attributes.
+ </p>
+ <p>In CPPA3, the <a href="#Signature">Signature</a> and <a href="#Encryption">Encryption</a> elements and the <em>requireSignature</em>
+ and <em>requireEncryption</em> attributes provide functionality similar to the CPPA2
+ <em>ApplicationCertificateRef</em> and <em>ApplicationCertificateDetails</em> elements. A
+ difference is that CPPA2 defined these at <em>CollaborationRole</em> level, whereas CPPA3
+ defines them at <a href="#PayloadPart">PayloadPart</a> level.
+ </p>
+ <p>Note that use of the <a href="#Signature">Signature</a> and <a href="#Encryption">Encryption</a> elements and the <em>requireSignature</em>
+ and <em>requireEncryption</em> attributes is not required when messaging is used in a payload-content
+ agnostic way. In that situation, messaging products MAY ignore the values of these elements.
+ However, in those situations CPPA3 may still be useful. For example, any distribution mechanisms
+ for CPPA3 could be leveraged to distribute keys to applications.
+ </p>
+ <p>In ebMS3, a <a href="#PayloadPart">PayloadPart</a> corresponds to an item on a
+ <em>PMode[1].BusinessInfo.PayloadProfile[]</em> list.</p>
+ <p>A <a href="#PayloadPart">PayloadPart</a> MAY be associated with one or
+ multiple <a href="#Schema">Schema</a> elements.
+ If more than one <a href="#Schema">Schema</a> element is specified, the part
+ MUST conform to all specified
+ schemas.
+ For example, an XML document may have to conform to both a generic XML document schema
+ and to a set of
+ transaction-specific business rules expressed in another schema language.
+ </p>
+ <p>For ebMS3, these elements in this type map to the payload properties defined for
+ <em>PayloadProfile[]</em> items, as defined in D.3.3. of ebMS3 CORE.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ <xs:element ref="cppa:PartName"/>
+ <xs:element ref="cppa:MIMEContentType" minOccurs="0"/>
+ <xs:element ref="cppa:Schema" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:MaxSize" minOccurs="0"/>
+ <xs:element ref="cppa:Property" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:Signature" maxOccurs="1" minOccurs="0"/>
+ <xs:element ref="cppa:Encryption" maxOccurs="1" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="minOccurs" type="xs:nonNegativeInteger"/>
+ <xs:attribute name="maxOccurs" type="cppa:maxoccurstype"/>
+ <xs:attribute name="requireSignature" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>To express that payload level signing is REQUIRED,
+ the <em>requireSignature</em> attribute MUST be set to the value true.
+ If the <em>requireSignature</em> attribute
+ is set to false or is absent, then the payload is not constrained to be signed.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="requireEncryption" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>To express that payload level encryption is REQUIRED,
+ the <em>requireEncryption</em> attribute MUST be set to the value true.
+ If the <em>requireEncryption</em> attribute
+ is set to false or is absent, then the payload is not constrained to be encrypted.
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ </xs:element>
+
+ <xs:element name="PartName" type="xs:token">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element specifies a name for the payload part. This element is used to map parts
+ defined in a payload profile to package definitions.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="MIMEContentType" type="xs:token">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Specifies the MIME content type of the part.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <!-- Schema and Document Constraints -->
+
+ <xs:element name="Schema">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Schema">Schema</a> element can be used to associate a
+ <a href="#PayloadPart">PayloadPart</a> with a particular schema.
+ For example, parts of type <em>application/xml</em> can be associated
+ with an XML schema.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="location" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The location of the schema as a URI.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="version" type="cppa:non-empty-string" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>If not specified in a located schema, the schema version can be specified using this
+ attribute.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="namespace" type="cppa:non-empty-string" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>For XML parts, this attribute specifies the namespace of the root element.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="element" type="cppa:non-empty-string" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>For XML parts, this attribute specifies the name of an XML element that MUST
+ be used as the root of the part.</p>
+ <p>If this attribute is used, for schemas that use namespaces the <em>namespace</em>
+ attribute MUST be set as well.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <!-- Packaging -->
+
+ <xs:element name="Packaging" type="cppa:PackagingType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Packaging">Packaging</a> element supports configuration of the physical packaging
+ of the message and
+ its payloads. It complements the <a href="#PayloadProfile">PayloadProfile</a> element that provides
+ a logical definition.
+ This element can be substituted by specialized elements, subject to
+ any constraints imposed by the message protocol. This version of CPPA
+ provides support for SOAP with Attachments, MTOM, MIME and simple SOAP packaging, but
+ supports extensibility to other container types.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="PackagingType" abstract="true">
+ <xs:sequence>
+ <xs:element ref="cppa:Description" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="id" type="xs:ID">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Identifier of the Package in the <a href="#CPP">CPP</a> or <a href="#CPA">CPA</a>.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:element name="MIMEEnvelope" substitutionGroup="cppa:Packaging" type="cppa:MIMEEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The MIMEEnvelope element supports packaging using the IETF MIME RFC 2045 specification for
+ multipart envelopers. It also supports protocols in which some parts are external to the
+ envelope but logically part of it.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="MIMEEnvelopeType">
+ <xs:complexContent>
+ <xs:extension base="cppa:PackagingType">
+ <xs:sequence>
+ <xs:element ref="cppa:MIMEPart" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ExternalPayload" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="MIMEPart" type="cppa:MIMEPartType" abstract="true">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Defines an individual abstract MIME envelope part. Substitutions are defined
+ for simple MIME parts, Multipart/Related MIME parts and compressed
+ variants of these. Additional substitutions could be defined for other
+ containers that could be transported as MIME envelope content.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="MIMEPartType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A MIME part type.</p>
+ <p>Note that there is no <em>MIMEContentType</em> element in this type, as
+ this is specified for the referenced <a href="#PayloadPart">PayloadPart</a>.
+ For compressed MIME parts, the MIME type follows from the compression
+ algorithm used.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:sequence/>
+ <xs:attribute name="ContentTransferEncoding" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute specifies a MIME Content-Transfer-Encoding that is
+ to be applied to the MIME part. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+
+ <xs:attributeGroup name="FNPreservation">
+ <xs:attribute name="PreserveFileName" type="xs:boolean" use="optional">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This attribute indicates whether the it is possible to process a <em>filename</em> parameter
+ for the <em>Content-Disposition</em> MIME part header as specified in [ediint-fn].
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+
+ </xs:attributeGroup>
+
+ <xs:attributeGroup name="PackagingForPayloadParts">
+ <xs:attribute name="PartName" type="xs:token" use="required">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#SOAPBodyPart">SOAPBodyPart</a> and MIME parts.</p>
+ <p>This attribute identifies a
+ <a href="#PayloadPart">PayloadPart</a> using its <a href="#PartName">PartName</a>. The PayloadPart must be
+ a part defined in the PayloadProfile associated with the action that links to
+ the package that contains this part.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:attributeGroup>
+
+ <xs:element name="SimpleMIMEPart" substitutionGroup="cppa:MIMEPart"
+ type="cppa:SimpleMIMEPartType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A simple MIME part, i.e. a part that is not itself a multipart part.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SimpleMIMEPartType">
+ <xs:complexContent>
+ <xs:extension base="cppa:MIMEPartType">
+ <xs:attributeGroup ref="cppa:PackagingForPayloadParts"/>
+ <xs:attributeGroup ref="cppa:FNPreservation"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="MIMEMultipartRelated" substitutionGroup="cppa:MIMEPart"
+ type="cppa:MIMEMultipartRelatedType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A Multipart/Related MIME part.</p>
+ <p>AS2 supports multiple payloads as a Multipart/Related structure [RFC6362].
+ A sending MSH that uses this feature MUST set the "MA" feature.
+ The <em>Version</em> of the <a href="#AS2Channel">AS2Channel</a>
+ MUST be set to <em>1.2</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="MIMEMultipartRelatedType">
+ <xs:complexContent>
+ <xs:extension base="cppa:MIMEPartType">
+ <xs:sequence>
+ <xs:element ref="cppa:MIMEPart" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="SimpleSOAPEnvelope" substitutionGroup="cppa:Packaging"
+ type="cppa:SimpleSOAPEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A Simple SOAP Envelope is an Envelope structured as defined in the SOAP 1.1 or
+ 1.2 specifications, i.e. not an envelope packaged using the W3C SOAP with Attachments
+ or MTOM specifications. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SimpleSOAPEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:PackagingType">
+ <xs:sequence>
+ <xs:sequence>
+ <xs:element ref="cppa:SOAPBodyPart" minOccurs="0"/>
+ <xs:element ref="cppa:ExternalPayload" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="SOAPBodyPart">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Payload packaging that uses the SOAP Body.</p>
+ <p>The identified PayloadPart must be
+ a part defined in the PayloadProfile associated with the action that links to
+ the <a href="#SOAPWithAttachmentsEnvelope">SOAPWithAttachmentsEnvelope</a>
+ package that contains this <a href="#SOAPBodyPart">SOAPBodyPart</a>.
+ The MIME Content Type of that <a href="#PayloadPart">PayloadPart</a> MUST be <em>application/xml</em>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:attributeGroup ref="cppa:PackagingForPayloadParts"/>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="SOAPWithAttachmentsEnvelope" substitutionGroup="cppa:Packaging"
+ type="cppa:SOAPWithAttachmentsEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#SOAPWithAttachmentsEnvelope">SOAPWithAttachmentsEnvelope</a> element
+ supports packaging using the W3C SOAP with
+ Attachements specification. </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SOAPWithAttachmentsEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>When used with the ebMS2 protocol or other protocols that use the SOAP Body to store
+ protocol-dependent data, the <a href="#SOAPBodyPart">SOAPBodyPart</a> MUST NOT be used.</p>
+ <p>When used with the ebMS3 protocol or other protocols that allow payload content to be
+ transported in the SOAP Body, the <a href="#SOAPBodyPart">SOAPBodyPart</a> element MAY be used to
+ identify a particular <a href="#PayloadPart">PayloadPart</a> that SHOULD be packaged in the SOAP Body.
+ Note that ebMS3 does not have any PMode parameters to control the placement of payloads.
+ </p>
+ <p>For interoperability, at most one XML element MAY be
+ included in the SOAP Body. If the <em>maxOccurs</em> for the identified PayloadPart is
+ greater than 1, only one of these MAY be included in the SOAP Body, meaning all others MUST
+ be transported as MIME parts or as external payloads.
+ </p>
+ <p>Note that the ebMS3 protocol allows an MSH to use a simple SOAP envelope (not using MIME)
+ for messages that consist of at most a single XML payload, carried in the SOAP Body.
+ Since there are no PMode parameters to control whether content is placed in the Body or
+ as an attachment, this means that an MSH MAY use a simple SOAP if there is just a single
+ uncompressed XML payload.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:PackagingType">
+ <xs:sequence>
+ <xs:sequence>
+ <xs:element ref="cppa:SOAPBodyPart" minOccurs="0"/>
+ <xs:element ref="cppa:MIMEPart" minOccurs="0" maxOccurs="unbounded"/>
+ <xs:element ref="cppa:ExternalPayload" minOccurs="0" maxOccurs="1"/>
+ </xs:sequence>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="ExternalPayload" type="cppa:ExternalPayloadType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An external payload is a payload that is not transported in the message, but is
+ logically part of it. The external payload instead is referenced.
+ The receiving MSH is responsible for dereferencing the reference, obtaining the
+ payload (e.g. via a secure download) and processing it.
+ </p>
+ <p>The channel that is to be used to retrieve the external payload is identified in the child
+ <a href="#ChannelID">ChannelID</a> element, which is connected to a transport.
+ Specified transport configuration for processing the referenced payload will be
+ available for the <a href="#Transport">Transport</a> associated with that channel.
+ This could configure, for example, use of IP addresses, client and server certificates,
+ and user authentication, to be used.
+ </p>
+ <p>Protocols supporting external payloads constrain the channels that
+ can be used to retrieve the external payloads.
+ In the case of ebMS2 or ebMS3, the payload content is not included
+ as a MIME part or as the SOAP Body in the ebMS3 message.
+ Instead, it is referenced using the <em>href</em> attribute:
+ </p>
+ <ul>
+ <li>In the case of ebMS2, using <em>Manifest/Reference/@href</em>.</li>
+ <li>In the case of ebMS3, using <em>PayloadInfo/PartInfo/@href</em>.</li>
+ </ul>
+ <p>
+ In this case, the value of the <em>href</em>attribute is a URI, and the mechanism to access
+ the payload is not an ebMS mechanism, but uses the transports associated with the URI.
+ For example, in the case of an <em>http(s)</em> URI, it is expected to be retrieved
+ using an HTTP GET request.
+ In CPPA3, this mechanism is supported by associating the external payload with a
+ <a href="#TransportChannel">TransportChannel</a>. Future (or other) protocols not currently
+ considered for CPPA3 may use other channel types for external payloads.
+ </p>
+ <p>In Enterprise Integration terminology, the <a href="#ExternalPayload">ExternalPayload</a> feature is an instance of
+ the <a href="http://www.enterpriseintegrationpatterns.com/patterns/messaging/StoreInLibrary.html">Claim Check</a>
+ pattern.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="ExternalPayloadType">
+ <xs:complexContent>
+ <xs:extension base="cppa:PackagingType">
+ <xs:sequence>
+ <xs:element ref="cppa:ChannelId" minOccurs="1" maxOccurs="1"/>
+ </xs:sequence>
+ <xs:attributeGroup ref="cppa:PackagingForPayloadParts"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:element name="MTOMEnvelope" substitutionGroup="cppa:Packaging" type="cppa:MTOMEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>An MTOM Envelope structured as defined in the MTOM specification [SOAP12-MTOM]. </p>
+ <p>An MTOM Envelop uses XOP [XOP] to transfer parts of the SOAP message as MIME parts.
+ However, from an XML infoset point of view, and in submission or delivery, there is
+ only one structure.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="MTOMEnvelopeType">
+ <xs:annotation>
+ <xs:documentation>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="cppa:PackagingType">
+ <xs:sequence>
+ <xs:sequence>
+ <xs:element ref="cppa:SOAPBodyPart" minOccurs="0"/>
+ <xs:element ref="cppa:ExternalPayload" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <!-- General elements and types -->
+
+ <xs:element name="Expression" type="cppa:non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element expresses an XPath expression. </p>
+ <p>If namespaces are used, XPath expressions MUST use namespaces in Clark notation
+ ({ns}name) to obviate the need for shared values and definitions of prefixes.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:element name="Description">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Description">Description</a> element provides a natural language description
+ related to a CPPA3 structure. Since its content is restricted to the
+ <a href="#non-empty-string">non-empty-string</a> type, it is not suited to contain
+ structured technical documentation. If deemed useful, the <em>href</em> attribute MAY be
+ used to reference external descriptions.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <!-- <xs:attribute ref="xml:lang" use="required">
+ <xs:annotation>
+ <xs:documentation>The language in which the description is provided.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="href" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>A optional reference to additional description material for the
+ structure.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute -->
+
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <!-- Access Control -->
+
+ <xs:attributeGroup name="acl_attributes">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <em>allowed</em> and <em>denied</em> attributes in a <a href="#CPP">CPP</a>
+ control which counterparty or counterparties can participate in an exchange with
+ the CPP's <a href="#Party">Party</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:attribute name="allowed" type="cppa:party_id_list_ref_type" use="optional">
+ <xs:annotation>
+ <xs:documentation>A reference to a list of allowed party identifiers.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="denied" type="cppa:party_id_list_ref_type" use="optional">
+ <xs:annotation>
+ <xs:documentation>A reference to a list of denied party identifiers.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:attributeGroup>
+
+ <xs:simpleType name="party_id_list_ref_type">
+ <xs:annotation>
+ <xs:documentation>A reference to a list of party identifiers. This list can be referenced
+ using an ID reference, if it is included in the <a href="#CPP">CPP</a>, or using a absolute URI,
+ if it is located using a Uniform Resource Locator and is located outside the <a href="#CPP">CPP</a>.
+ </xs:documentation>
+ </xs:annotation>
+ <xs:union memberTypes="xs:anyURI xs:IDREF"/>
+ </xs:simpleType>
+
+ <xs:simpleType name="non-empty-string">
+ <xs:annotation>
+ <xs:documentation>
+ <xs:documentation>A non-empty string.</xs:documentation>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:minLength value="1"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+ <xs:element name="MaxSize" type="cppa:SizeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Define the maximum value for some size aspect of a message or message part.</p>
+ </xs:documentation>
+ </xs:annotation>
+ </xs:element>
+
+ <xs:complexType name="SizeType">
+ <xs:annotation>
+ <xs:documentation>
+ <p>Defines a size in octets. If the <em>unit</em> attribute is not present, the
+ value of the attribute MUST be a positive integer.
+ If the <em>unit</em> attribute is present with a value U for an element E of
+ type <em>SizeType</em>,
+ the value V of the attribute is equivalent to the attribute being absent on E
+ and the value V multiplied by the BIPM interpretation of the unit prefix.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleContent>
+ <xs:extension base="cppa:posfloat">
+ <xs:attribute name="unit" use="optional">
+ <xs:annotation>
+ <xs:documentation>The optional <em>unit</em> attribute aims to facilitate
+ human-readable size specification using
+ BIPM (International Bureau of Weights and Measures) symbol prefix, e.g.
+ use <em>k</em> for 10<sup>3</sup> or <em>G</em> for 10<sup>9</sup> sizes.
+ </xs:documentation>
+ </xs:annotation>
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="da"/>
+ <xs:enumeration value="h"/>
+ <xs:enumeration value="k"/>
+ <xs:enumeration value="M"/>
+ <xs:enumeration value="G"/>
+ <xs:enumeration value="T"/>
+ <xs:enumeration value="P"/>
+ <xs:enumeration value="E"/>
+ <xs:enumeration value="Z"/>
+ <xs:enumeration value="Y"/>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+
+ <xs:simpleType name="posfloat">
+ <xs:restriction base="xs:float">
+ <xs:minExclusive value="0"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+ <xs:simpleType name="unboundedtype">
+ <xs:restriction base="xs:string">
+ <xs:enumeration value="unbounded"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+ <xs:simpleType name="maxoccurstype">
+ <xs:union memberTypes="xs:nonNegativeInteger cppa:unboundedtype"/>
+ </xs:simpleType>
+
+ <xs:simpleType name="usetype">
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="optional"/>
+ <xs:enumeration value="required"/>
+ </xs:restriction>
+ </xs:simpleType>
+
+</xs:schema>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/exception.xsd b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/exception.xsd
new file mode 100755
index 0000000000000000000000000000000000000000..5ae3089b2951053ee632991e5185d4ef27548240
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/main/resources/xsd/exception.xsd
@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Collaboration Protocol Profile and Agreement Version 3.0
+ Committee Specification 01
+ 24 September 2020
+
+ Copyright (c) OASIS Open 2020. All Rights Reserved.
+ Source: https://docs.oasis-open.org/ebcore/cppa/v3.0/cs01/
+ Latest version of narrative specification: https://docs.oasis-open.org/ebcore/cppa/v3.0/cppa-v3.0.html
+ TC IPR Statement: https://www.oasis-open.org/committees/ebcore/ipr.php
+-->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xml="http://www.w3.org/XML/1998/namespace"
+ xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+ xmlns:h="http://www.w3.org/1999/xhtml"
+ xmlns:cppa="http://docs.oasis-open.org/ebcore/ns/cppa/v3.0"
+ xmlns:dsig11="http://www.w3.org/2009/xmldsig11#"
+ xmlns:exc="http://docs.oasis-open.org/ebcore/ns/exception/v3.0"
+ targetNamespace="http://docs.oasis-open.org/ebcore/ns/exception/v3.0" elementFormDefault="qualified"
+ attributeFormDefault="unqualified" version="1.0">
+
+ <xs:import namespace="http://docs.oasis-open.org/ebcore/ns/cppa/v3.0" schemaLocation="cppa3.xsd">
+ <xs:annotation>
+ <xs:documentation>The CPPA3 Schema, from which this schema uses some sub-elements.</xs:documentation>
+ </xs:annotation>
+ </xs:import>
+
+ <xs:annotation>
+ <xs:documentation>
+ <p>This XML schema is part of the
+ <a href="http://docs.oasis-open.org/ebcore/cppa/v3.0/">OASIS CPPA3 specification</a>
+ developed by the <a href="https://www.oasis-open.org/committees/ebcore/">OASIS ebCore TC</a>.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+
+ <xs:element name="Exception">
+ <xs:annotation>
+ <xs:documentation>
+ <p>A CPPA3 Exception document is used to communicate the rejection of a proposed CPPA3
+ Agreement to the party that requested registration of the Agreement. </p>
+ <p>An Exception document MUST include an <em>AgreementIdentifier</em>
+ element. The value of this element MUST be set to the value of the presented proposed
+ Agreement.</p>
+ <p>An Exception document MAY include a <em>ProfileIdentifier</em>
+ element. If it is present, the value of this element MUST identify a CPPA3 Profile against
+ which the presented CPPA3 Agreement is matched.</p>
+ <p>An Exception document MAY include any number of <a href="#Error">Error</a> elements.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element ref="cppa:AgreementIdentifier" />
+ <xs:element ref="cppa:ProfileIdentifier" minOccurs="0" maxOccurs="1"/>
+ <xs:element ref="exc:Error" minOccurs="0" maxOccurs="unbounded" />
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="Error" >
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element reports an error. The structure of the element is similar to the Error elements of
+ ebMS3 and ebCore Agreement Update.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType >
+ <xs:sequence>
+ <xs:element ref="exc:Description" minOccurs="0"/>
+ <xs:element ref="exc:ErrorDetail" minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="errorCode" type="xs:token" use="required">
+ <xs:annotation>
+ <xs:documentation>A code for the error.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="severity" type="xs:token" use="required">
+ <xs:annotation>
+ <xs:documentation>The severity of the error. Values include <em>Failure</em>
+ and <em>Warning</em>.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="shortDescription" type="xs:token" use="optional">
+ <xs:annotation>
+ <xs:documentation>A short description for the error.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="Description">
+ <xs:annotation>
+ <xs:documentation>
+ <p>The <a href="#Description">Description</a> element provides a natural language description
+ for an <a href="#Error">Error</a>. Since its content is restricted to the
+ <em>non-empty-string</em> type, it is not suited to contain
+ structured technical documentation. If deemed useful, the <em>href</em> attribute MAY be
+ used to reference external descriptions.
+ </p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute ref="xml:lang" use="required">
+ <xs:annotation>
+ <xs:documentation>The language in which the description is provided.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="href" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>A optional reference to additional description material for the
+ structure.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:element name="ErrorDetail" >
+ <xs:annotation>
+ <xs:documentation>
+ <p>This element allows more detailed explanation of errors.</p>
+ </xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="cppa:non-empty-string">
+ <xs:attribute ref="xml:lang" use="required">
+ <xs:annotation>
+ <xs:documentation>The language in which the explanation is provided.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ <xs:attribute name="href" type="xs:anyURI" use="optional">
+ <xs:annotation>
+ <xs:documentation>A optional reference to additional description material for the
+ structure.</xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/smp-resource-extensions/oasis-cppa3-spi/src/test/java/eu/europa/ec/smp/spi/handler/OasisCppa3CppHandlerTest.java b/smp-resource-extensions/oasis-cppa3-spi/src/test/java/eu/europa/ec/smp/spi/handler/OasisCppa3CppHandlerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..aff02938a01b84544a7c6b1a58d360861fcd4f26
--- /dev/null
+++ b/smp-resource-extensions/oasis-cppa3-spi/src/test/java/eu/europa/ec/smp/spi/handler/OasisCppa3CppHandlerTest.java
@@ -0,0 +1,54 @@
+package eu.europa.ec.smp.spi.handler;
+
+import eu.europa.ec.smp.spi.api.SmpDataServiceApi;
+import eu.europa.ec.smp.spi.api.SmpIdentifierServiceApi;
+import eu.europa.ec.smp.spi.api.model.RequestData;
+import eu.europa.ec.smp.spi.api.model.ResourceIdentifier;
+import eu.europa.ec.smp.spi.api.model.ResponseData;
+import eu.europa.ec.smp.spi.exceptions.ResourceException;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.Collections;
+
+import static org.junit.Assert.*;
+
+public class OasisCppa3CppHandlerTest {
+
+
+ SmpDataServiceApi smpDataApi = Mockito.mock(SmpDataServiceApi.class);
+ SmpIdentifierServiceApi smpIdentifierServiceApi = Mockito.mock(SmpIdentifierServiceApi.class);
+ OasisCppa3CppHandler testInstance = new OasisCppa3CppHandler(smpDataApi, smpIdentifierServiceApi);
+
+
+ RequestData requestData = Mockito.mock(RequestData.class);
+ ResponseData responseData = Mockito.mock(ResponseData.class);
+
+
+ @Test
+ public void generateAndValidateResource() throws ResourceException {
+ ResourceIdentifier resourceIdentifier = new ResourceIdentifier("test-identifier", "test-test-test");
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ Mockito.doReturn(resourceIdentifier).when(requestData).getResourceIdentifier();
+ Mockito.doReturn(baos).when(responseData).getOutputStream();
+
+ testInstance.generateResource(requestData, responseData, Collections.emptyList());
+
+ Mockito.doReturn(resourceIdentifier).when(requestData).getResourceIdentifier();
+ Mockito.doReturn(baos).when(responseData).getOutputStream();
+ assertTrue(baos.size()>0);
+ System.out.println(baos.toString());
+ // validate
+ ByteArrayInputStream bios = new ByteArrayInputStream(baos.toByteArray());
+ Mockito.doReturn(bios).when(requestData).getResourceInputStream();
+ Mockito.doReturn(resourceIdentifier).when(smpIdentifierServiceApi).normalizeResourceIdentifier(Mockito.anyString(),Mockito.anyString());
+
+ testInstance.validateResource(requestData);
+
+
+
+ }
+}
diff --git a/smp-resource-extensions/pom.xml b/smp-resource-extensions/pom.xml
index 1691f67a12709b2b6cdf683d9313d269814d4ca5..45a8d6f979e4b9eadfccf0e445e3cdddb7e98e1f 100644
--- a/smp-resource-extensions/pom.xml
+++ b/smp-resource-extensions/pom.xml
@@ -26,6 +26,6 @@
<description>The sub-project contains SMP examples of API and SPI implementations. Currently, SPI payload validation example.</description>
<modules>
<module>oasis-smp-spi</module>
- <!-- module>oasis-cppa3-spi</module -->
+ <module>oasis-cppa3-spi</module>
</modules>
</project>
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/config/enums/SMPPropertyEnum.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/config/enums/SMPPropertyEnum.java
index bfe098f78152713bbf58a697f4621e8f1fbf06a5..91d68b482c8aca31e2064a55d38bbd2d7d055c95 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/config/enums/SMPPropertyEnum.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/config/enums/SMPPropertyEnum.java
@@ -81,6 +81,8 @@ public enum SMPPropertyEnum {
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, URL),
SML_PHYSICAL_ADDRESS("bdmsl.integration.physical.address", "0.0.0.0", "Physical SMP endpoint which will be registered on SML when registering new domain.",
OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, STRING),
+ SML_CUSTOM_NAPTR_SERVICE_PARAMS("bdmsl.integration.naptr_service.map", "edelivery-oasis-cppa-3.0-cpp:meta:cppa3", "naptr service for resource type as key:value properties separated with '|'. Ex edelivery-oasis-cppa3-extension:meta:cppa3 ",
+ OPTIONAL, NOT_ENCRYPTED, NO_RESTART_NEEDED, MAP_STRING),
// keystore truststore
KEYSTORE_PASSWORD("smp.keystore.password", "", "Encrypted keystore (and keys) password ",
OPTIONAL, ENCRYPTED, NO_RESTART_NEEDED, STRING),
@@ -204,6 +206,7 @@ public enum SMPPropertyEnum {
OPTIONAL, NOT_ENCRYPTED, RESTART_NEEDED, STRING),
SSO_CAS_TOKEN_VALIDATION_PARAMS("smp.sso.cas.token.validation.params", "acceptStrengths:BASIC,CLIENT_CERT|assuranceLevel:TOP", "The CAS token validation key:value properties separated with '|'.Ex: 'acceptStrengths:BASIC,CLIENT_CERT|assuranceLevel:TOP'",
OPTIONAL, NOT_ENCRYPTED, RESTART_NEEDED, MAP_STRING),
+
SSO_CAS_TOKEN_VALIDATION_GROUPS("smp.sso.cas.token.validation.groups", "DIGIT_SMP|DIGIT_ADMIN", "'|' separated CAS groups user must belong to.",
OPTIONAL, NOT_ENCRYPTED, RESTART_NEEDED, LIST_STRING),
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/SmlIdentifierConverter.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/SmlIdentifierConverter.java
index e74e29bc67e65b70b26e84ddb929aa078b1b6c46..4706006d3b74671b90839a356b7365fee5d929b7 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/SmlIdentifierConverter.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/SmlIdentifierConverter.java
@@ -15,6 +15,7 @@
package eu.europa.ec.edelivery.smp.conversion;
+import ec.services.wsdl.bdmsl.data._1.SMPAdvancedServiceForParticipantType;
import eu.europa.ec.edelivery.smp.identifiers.Identifier;
import org.busdox.servicemetadata.locator._1.ServiceMetadataPublisherServiceForParticipantType;
@@ -41,4 +42,21 @@ public class SmlIdentifierConverter {
busdoxIdentifier.setParticipantIdentifier(parId);
return busdoxIdentifier;
}
+
+
+ public static SMPAdvancedServiceForParticipantType toBDMSLAdvancedParticipantId(Identifier participantId, String smpId, String serviceMetadata) {
+ if (isBlank(smpId)) {
+ throw new IllegalStateException("SMP ID is null or empty");
+ }
+ if (participantId == null || isBlank(participantId.getValue())) {
+ throw new IllegalStateException("Participant Scheme or Id is null or empty");
+ }
+
+ SMPAdvancedServiceForParticipantType bdmslRequest = new SMPAdvancedServiceForParticipantType();
+ bdmslRequest.setServiceName(serviceMetadata);
+
+ ServiceMetadataPublisherServiceForParticipantType bdxlRequest = toBusdoxParticipantId(participantId, smpId);
+ bdmslRequest.setCreateParticipantIdentifier(bdxlRequest);
+ return bdmslRequest;
+ }
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java
index 1985fe73f17c76915f77b69117b678ef525bbcd0..bf1828064ea61acbf11b4ca13994a949778d5709 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ConfigurationService.java
@@ -365,6 +365,10 @@ public class ConfigurationService {
return configurationDAO.getCachedPropertyValue(SSO_CAS_TOKEN_VALIDATION_PARAMS);
}
+ public Map<String, String> getCustomNaptrServicesMap() {
+ return configurationDAO.getCachedPropertyValue(SML_CUSTOM_NAPTR_SERVICE_PARAMS);
+ }
+
public List<String> getCasURLTokenValidationGroups() {
return configurationDAO.getCachedPropertyValue(SSO_CAS_TOKEN_VALIDATION_GROUPS);
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java
index d4fe05096427b0eea087acfc966b3b046f1690b8..981a2b34bcc6d6eb6be70e2f80cfbea15c7c74d4 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationService.java
@@ -10,11 +10,12 @@ import eu.europa.ec.edelivery.smp.identifiers.Identifier;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.sml.SmlConnector;
+import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
-
+import java.util.Map;
import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.CONFIGURATION_ERROR;
import static eu.europa.ec.edelivery.smp.logging.SMPMessageCode.*;
@@ -102,11 +103,32 @@ public class SMLIntegrationService {
if (!resource.isSmlRegistered()) {
// update value
resource.setSmlRegistered(true);
- smlConnector.registerInDns(normalizedParticipantId, domain);
+ String customNaptrService = getNaptrServiceForResource(resource);
+ smlConnector.registerInDns(normalizedParticipantId, domain, customNaptrService);
LOG.businessDebug(BUS_SML_REGISTER_SERVICE_GROUP, resource.getIdentifierValue(), resource.getIdentifierScheme(), domain.getDomainCode());
} else {
LOG.businessWarn(BUS_SML_REGISTER_SERVICE_GROUP_ALREADY_REGISTERED, resource.getIdentifierValue(), resource.getIdentifierScheme(), domain.getDomainCode());
}
+ }
+
+ public String getNaptrServiceForResource(DBResource resource){
+ LOG.info("Get naptr service for resource: [{}]", resource );
+ if (resource == null
+ || resource.getDomainResourceDef() == null
+ || resource.getDomainResourceDef().getResourceDef() == null
+ || StringUtils.isBlank(resource.getDomainResourceDef().getResourceDef().getIdentifier())){
+ LOG.info("return null naptr service for resource: [{}]", resource );
+ return null;
+ }
+ String resDefIdentifier = resource.getDomainResourceDef().getResourceDef().getIdentifier();
+ LOG.info("return null naptr service for resource: [{}] and document type [{}]", resource, resDefIdentifier );
+ Map<String, String> map = configurationService.getCustomNaptrServicesMap();
+
+ if (map!=null && map.containsKey(resDefIdentifier) ) {
+ return map.get(resDefIdentifier);
+ }
+ LOG.info("return null because configuration does not have document type and document type [{}]", resource, resDefIdentifier );
+ return null;
}
@@ -155,26 +177,6 @@ public class SMLIntegrationService {
return smlConnector.unregisterFromDns(normalizedParticipantId, domain);
}
-
- /**
- * Method registers participant to SML. It does not check if Participant is in database or of is already registered
- *
- * @param participantId - Participant schema
- * @param participantSchema - Participant schema
- * @param domain - register to domain
- */
-
- public boolean registerParticipantToSML(String participantId, String participantSchema, DBDomain domain) {
- LOG.businessDebug(BUS_SML_UNREGISTER_SERVICE_GROUP, participantId, participantSchema, domain.getDomainCode());
-
- Identifier normalizedParticipantId = identifierService
- .normalizeParticipant(participantSchema, participantId);
-
- // unregister only registered participants
- return smlConnector.registerInDns(normalizedParticipantId, domain);
-
- }
-
public boolean isSMLIntegrationEnabled() {
return configurationService.isSMLIntegrationEnabled();
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlClientFactory.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlClientFactory.java
index 6f4116ea7cbed2c44123cac577d2e02282905b9d..3abd75b444f4e5f6bae1474789b7852b3af804aa 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlClientFactory.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlClientFactory.java
@@ -15,10 +15,7 @@
package eu.europa.ec.edelivery.smp.sml;
-import eu.europa.ec.bdmsl.ws.soap.IManageParticipantIdentifierWS;
-import eu.europa.ec.bdmsl.ws.soap.IManageServiceMetadataWS;
-import eu.europa.ec.bdmsl.ws.soap.ManageBusinessIdentifierService;
-import eu.europa.ec.bdmsl.ws.soap.ManageServiceMetadataService;
+import eu.europa.ec.bdmsl.ws.soap.*;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
@@ -50,8 +47,6 @@ public class SmlClientFactory {
@Scope("prototype")
public IManageParticipantIdentifierWS create() {
LOG.info("create IManageParticipantIdentifierWS");
-
-
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
factory.getClientFactoryBean().getServiceFactory()
.setWsdlURL(ManageBusinessIdentifierService.class.getResource("/ManageBusinessIdentifierService-1.0.wsdl"));
@@ -72,4 +67,17 @@ public class SmlClientFactory {
factory.setEndpointName(ManageServiceMetadataService.ManageServiceMetadataServicePort);
return factory.create(IManageServiceMetadataWS.class);
}
+
+ @Bean
+ @Scope("prototype")
+ public IBDMSLServiceWS createBDMSLCustomServices() {
+ LOG.info("create IBDMSLServiceWS");
+
+ JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
+ factory.getClientFactoryBean().getServiceFactory()
+ .setWsdlURL(BDMSLService.class.getResource("/BDMSLService-1.0.wsdl"));
+ factory.setServiceName(BDMSLService.SERVICE);
+ factory.setEndpointName(BDMSLService.BDMSLServicePort);
+ return factory.create(IBDMSLServiceWS.class);
+ }
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java
index 10b0c69cf320e8ee9bfd3b25260c0641afd87e6c..cecc91f2b157b1ce8d6f67721689e8d2333293cc 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/sml/SmlConnector.java
@@ -13,10 +13,8 @@
package eu.europa.ec.edelivery.smp.sml;
-import eu.europa.ec.bdmsl.ws.soap.BadRequestFault;
-import eu.europa.ec.bdmsl.ws.soap.IManageParticipantIdentifierWS;
-import eu.europa.ec.bdmsl.ws.soap.IManageServiceMetadataWS;
-import eu.europa.ec.bdmsl.ws.soap.NotFoundFault;
+import ec.services.wsdl.bdmsl.data._1.SMPAdvancedServiceForParticipantType;
+import eu.europa.ec.bdmsl.ws.soap.*;
import eu.europa.ec.edelivery.smp.config.enums.SMPPropertyEnum;
import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
@@ -57,6 +55,7 @@ import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
+import static eu.europa.ec.edelivery.smp.conversion.SmlIdentifierConverter.toBDMSLAdvancedParticipantId;
import static eu.europa.ec.edelivery.smp.conversion.SmlIdentifierConverter.toBusdoxParticipantId;
import static eu.europa.ec.edelivery.smp.exceptions.SMLErrorMessages.*;
@@ -74,6 +73,8 @@ public class SmlConnector implements ApplicationContextAware {
private static final String SERVICE_METADATA_CONTEXT = "manageservicemetadata";
private static final String IDENTIFIER_VALUE_CONTEXT = "manageparticipantidentifier";
+ private static final String BDMSL_CUSTOM_SERVICES_CONTEXT = "bdmslservice";
+
private static final String CLIENT_CERT_HEADER_KEY = "Client-Cert";
@Autowired
@@ -91,7 +92,7 @@ public class SmlConnector implements ApplicationContextAware {
private ApplicationContext ctx;
- public boolean registerInDns(Identifier normalizedParticipantId, DBDomain domain) {
+ public boolean registerInDns(Identifier normalizedParticipantId, DBDomain domain, String customNaptrService) {
if (!configurationService.isSMLIntegrationEnabled()) {
@@ -106,9 +107,13 @@ public class SmlConnector implements ApplicationContextAware {
LOG.debug("Registering new Participant: {} to domain: {}.", normalizedParticipantString, domain.getDomainCode());
try {
- ServiceMetadataPublisherServiceForParticipantType smlRequest = toBusdoxParticipantId(normalizedParticipantId, domain.getSmlSmpId());
- getParticipantWSClient(domain).create(smlRequest);
- LOG.info("Participant: {} registered to domain: {}.", normalizedParticipantString, domain.getDomainCode());
+ if (StringUtils.isBlank(customNaptrService)) {
+ createRegularDNSRecord(normalizedParticipantId, domain);
+ LOG.info("Set regular DNS record for Participant: [{}] and domain: [{}].", normalizedParticipantId, domain.getDomainCode());
+ } else {
+ createCustomServiceNaptrDNSRecord(normalizedParticipantId, domain, customNaptrService);
+ LOG.info("Set custom naptr service [{}] DNS record for Participant: [{}] and domain: [{}].", customNaptrService, normalizedParticipantId, domain.getDomainCode());
+ }
return true;
} catch (BadRequestFault e) {
return processSMLErrorMessage(e, normalizedParticipantId);
@@ -120,6 +125,17 @@ public class SmlConnector implements ApplicationContextAware {
}
}
+ protected void createRegularDNSRecord(Identifier normalizedParticipantId, DBDomain domain) throws UnauthorizedFault, BadRequestFault, NotFoundFault, InternalErrorFault {
+ LOG.debug("Set regular DNS record for Participant: [{}] and domain: [{}].", normalizedParticipantId, domain.getDomainCode());
+ ServiceMetadataPublisherServiceForParticipantType smlRequest = toBusdoxParticipantId(normalizedParticipantId, domain.getSmlSmpId());
+ getParticipantWSClient(domain).create(smlRequest);
+ }
+ protected void createCustomServiceNaptrDNSRecord(Identifier normalizedParticipantId, DBDomain domain, String customNaptrService) throws UnauthorizedFault, BadRequestFault, NotFoundFault, InternalErrorFault {
+ LOG.debug("Set custom naptr service [{}] DNS record for Participant: [{}] and domain: [{}].", customNaptrService, normalizedParticipantId, domain.getDomainCode());
+ SMPAdvancedServiceForParticipantType smlRequest = toBDMSLAdvancedParticipantId(normalizedParticipantId, domain.getSmlSmpId(), customNaptrService);
+ getBDMSLWSClient(domain).createParticipantIdentifier(smlRequest);
+ }
+
protected boolean processSMLErrorMessage(BadRequestFault e, Identifier participantIdentifierType) {
if (!isOkMessage(participantIdentifierType, e.getMessage())) {
LOG.error(e.getMessage(), e);
@@ -271,6 +287,15 @@ public class SmlConnector implements ApplicationContextAware {
return iManageServiceMetadataWS;
}
+ private IBDMSLServiceWS getBDMSLWSClient(DBDomain domain) {
+
+ IBDMSLServiceWS bdmslServiceWS = ctx.getBean(IBDMSLServiceWS.class);
+ // configure connection
+ configureClient(BDMSL_CUSTOM_SERVICES_CONTEXT, bdmslServiceWS, domain);
+
+ return bdmslServiceWS;
+ }
+
private IManageServiceMetadataWS getSMPManagerWSClient(DBDomain domain) {
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java
index 585c3a090ea27c4389e8dd2e95040a2a3c50d093..68019288b68685ab4be002f7ee6ddefb2a495441 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/SMLIntegrationServiceTest.java
@@ -202,6 +202,7 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
}
*/
+ /*
@Test
public void registerParticipantToSML() throws NotFoundFault, UnauthorizedFault, InternalErrorFault, BadRequestFault {
DBDomain testDomain01 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
@@ -213,7 +214,7 @@ public class SMLIntegrationServiceTest extends AbstractServiceIntegrationTest {
verify(integrationMock.getParticipantManagmentClientMocks().get(0)).create(any());
Mockito.verifyNoMoreInteractions(integrationMock.getParticipantManagmentClientMocks().toArray());
}
-/*
+
@Test
public void unregisterParticipantFromSML() throws NotFoundFault, UnauthorizedFault, InternalErrorFault, BadRequestFault {
DBDomain testDomain01 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorParticipantTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorParticipantTest.java
index 36ae5ad06a561b191684ba9550870960b7966ab4..7651f376b434d7eaa8ed95ef77f131f6fcc9d2e3 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorParticipantTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/sml/SmlConnectorParticipantTest.java
@@ -76,7 +76,7 @@ public class SmlConnectorParticipantTest extends AbstractServiceIntegrationTest
@Test
public void testRegisterInDns() throws UnauthorizedFault, NotFoundFault, InternalErrorFault, BadRequestFault {
//when
- boolean result = testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN);
+ boolean result = testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN, null);
//then
assertTrue(result);
@@ -90,7 +90,7 @@ public class SmlConnectorParticipantTest extends AbstractServiceIntegrationTest
//when
BadRequestFault ex = new BadRequestFault(ERROR_PI_ALREADY_EXISTS);
mockSml.setThrowException(ex);
- boolean result = testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN);
+ boolean result = testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN, null);
//then
assertTrue(result);
@@ -108,14 +108,14 @@ public class SmlConnectorParticipantTest extends AbstractServiceIntegrationTest
expectedException.expectMessage(message);
expectedException.expect(SMPRuntimeException.class);
- testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN);
+ testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN, null);
}
@Test
public void testRegisterInDnsNewClientIsAlwaysCreated() throws UnauthorizedFault, NotFoundFault, InternalErrorFault, BadRequestFault {
//when
- testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN);
- testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN);
+ testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN , null );
+ testInstance.registerInDns(PARTICIPANT_ID, DEFAULT_DOMAIN , null);
//then
assertEquals(2, mockSml.getParticipantManagmentClientMocks().size());
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java
index 621fe0b4f61c7fd97dd8e7ea3606ae8067456ea8..b86c9f23f2d68ae50df975c924017ea08187a13a 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/utils/PropertyUtilsTest.java
@@ -13,6 +13,7 @@ import org.springframework.scheduling.support.CronExpression;
import java.io.File;
import java.nio.file.Paths;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
@@ -142,6 +143,26 @@ public class PropertyUtilsTest {
}
+ @Test
+ public void testParseMapPropertiesToType() {
+ //when then
+ String value= "test1:val1|test2:val2|test3:val:with:colon|test4: val-no-spaces";
+
+ Object obj = PropertyUtils.parseProperty(SML_CUSTOM_NAPTR_SERVICE_PARAMS, value, ROOT_FOLDER);
+ assertEquals(HashMap.class, obj.getClass());
+ Map<String, String> maRes= (Map<String, String>)obj;
+
+ assertTrue(maRes.containsKey("test1"));
+ assertEquals("val1", maRes.get("test1"));
+ assertTrue(maRes.containsKey("test2"));
+ assertEquals("val2", maRes.get("test2"));
+ assertTrue(maRes.containsKey("test3"));
+ assertEquals("val:with:colon", maRes.get("test3"));
+ assertTrue(maRes.containsKey("test4"));
+ assertEquals("val-no-spaces", maRes.get("test4"));
+ }
+
+
@Test
@Parameters(method = "testTypeValues")
public void testParsePropertyType(SMPPropertyTypeEnum propertyType, String value, boolean expectParseOk) {
diff --git a/smp-webapp/pom.xml b/smp-webapp/pom.xml
index 9d23d03fa152a5aa51700f7a7e23c2ed0dc42dd5..ea1d6a58a3056dd117f4c76cde140293d5a3a419 100644
--- a/smp-webapp/pom.xml
+++ b/smp-webapp/pom.xml
@@ -33,6 +33,13 @@
<artifactId>oasis-smp-spi</artifactId>
<version>${project.version}</version>
</dependency>
+ <!-- cppa3 document -->
+ <!-- dependency>
+ <groupId>eu.europa.ec.edelivery</groupId>
+ <artifactId>oasis-cppa3-spi</artifactId>
+ <version>${project.version}</version>
+ </dependency -->
+
<dependency>
<groupId>eu.europa.ec.dynamic-discovery</groupId>
<artifactId>dynamic-discovery-client</artifactId>