Xsd and multiple inheritance
<p>Sorry for such a long question. I'll try to make it as simple as it gets.
We are working on a modular computational framework. The framework reads the configuration from xml file and we would like to validate the configuration against xsd. While adding new modules, we would like the xsd to be as simple as possible in the sense of maintainability. 
The structure of framework is the following (in c#):</p>

<pre><code>interface IModule { ... }
interface ISource : IModule { ... }
interface IFilter : IModule { ... }
interface IProcessor : IModule { ... }
</code></pre>

<p>and we have abstract implementation of various module interfaces and the implementation of modules (e.g. ObjLoader : AbstractSource). The structure of xml is following:</p>

<pre><code>&lt;Test&gt;
    &lt;Sources&gt;
       &lt;ObjLoader .../&gt;
    &lt;/Sources&gt;
    &lt;Filters&gt;
       ...
    &lt;/Filters&gt;
    &lt;Processors&gt;
    ...
&lt;/Test&gt;
</code></pre>

<p>Currently to avoid the necessity to heavily modify the xsd with every new module, we have the following test.xsd:</p>

<pre><code>&lt;xs:include schemaLocation="framework.xsd"/&gt;
&lt;xs:include ... modules /&gt; 
&lt;!-- adding includes for every module or group 
of modules is the only modification --&gt;

&lt;xs:element name="Test"&gt;
  &lt;xs:complexType&gt;
    &lt;xs:sequence&gt;
      &lt;xs:element ref="this:Sources" 
                  minOccurs="1" 
                  maxOccurs="1"/&gt;
      ...
    &lt;/xs:sequence&gt;
  &lt;/xs:complexType&gt;
&lt;/xs:element&gt;
</code></pre>

<p>and common framework.xsd:</p>

<pre><code>&lt;xs:element name="Sources"&gt;
  &lt;xs:complexType&gt;
    &lt;xs:choice maxOccurs="unbounded"&gt;
      &lt;xs:element ref="this:AbstractSource"/&gt;
    &lt;/xs:choice&gt;
  &lt;/xs:complexType&gt;
&lt;/xs:element&gt;

&lt;xs:element name="AbstractSource" 
            abstract="true"/&gt;  

&lt;xs:complexType name="ISource"&gt;
  &lt;xs:complexContent&gt;
    &lt;xs:extension base="this:IModule"&gt;
      ...
    &lt;/xs:extension&gt;
  &lt;/xs:complexContent&gt;
&lt;/xs:complexType&gt;
...
</code></pre>

<p>Each module (or group of modules) has its own xsd file with its definition and this file is included in the test.xsd:</p>

<pre><code>&lt;xs:include schemaLocation="framework.xsd"/&gt;

&lt;xs:element name="ObjLoader" 
    substitutionGroup="this:AbstractSource"&gt;
  &lt;xs:complexType&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base="this:ISource"&gt;
        ...
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;
&lt;/xs:element&gt;
</code></pre>

<p>So far so good and everything works well. For each dll with modules we provide corresponding xsd and include it in test.xsd. But during the development, modules that are primarily of some kind, but can produce another operation as a side effect appeared. It is not a problem in the c# side as we can have the following class:</p>

<pre><code>class GreatProcessingFilter : AbstractProcessor, 
                              IFilter { ... }
</code></pre>

<p>Is there a way to modify our xsd to be able to handle such elements that can be a substitution of multiple abstract elements? Something like:</p>

<pre><code>&lt;xs:element name="GreatProcessingFilter" 
            substitutionGroup="AbstractProcessor" 
            substitutionGroup="AbstractFilter"&gt; ... 
</code></pre>