client-lib, client-app und server-app aus den jeweiligen projekten importiert. api-definition begonnen zu implementieren

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

api-definition/src/main/java/com/kapdion/pisano/ApiConstants.java

@@ -0,0 +1,9 @@
+package com.kapdion.pisano;
+
+public class ApiConstants {
+    public static final String VOCAB_PATH = "vocab.jsonld";
+    public static final String CONTEXT_PATH = "context.jsonld";
+    public static final String JSON_LD_MIME = "application/ld+json";
+
+    public static final String VOCAB_URL = "https://bureau.kapdion.com/produktwissen-app/produktApi/vocab";
+}

api-definition/src/main/resources/context.jsonld

@@ -0,0 +1,30 @@
+{
+  "@context": {
+    "api": "https://bureau.kapdion.com/produktwissen-app/produktApi/vocab#",
+    "vvo": "http://vvo.pisanoapi.at/",
+    "hydra": "http://www.w3.org/ns/hydra/core#",
+    "xsd": "http://www.w3.org/2001/XMLSchema#",
+
+    "ProductsRequest": "api:ProductsRequest",
+    "ProductsResponse": "api:ProductsResponse",
+    "CalculateRequest": "api:CalculateRequest",
+    "CalculateResponse": "api:CalculateResponse",
+    "ProdElement": "vvo:ProdElement",
+    "Meldung": "vvo:Meldung",
+
+    "stichtag": {
+      "@id": "api:stichtag",
+      "@type": "xsd:date"
+    },
+
+    "bez": "vvo:bez",
+    "value": "vvo:value",
+    "required": { "@id": "vvo:required", "@type": "xsd:boolean" },
+    "minOccurrence": { "@id": "vvo:minOccurrence", "@type": "xsd:int" },
+    "maxOccurrence": { "@id": "vvo:maxOccurrence", "@type": "xsd:int" },
+    "errorMsg": "vvo:errorMsg",
+    "errorType": "vvo:errorType",
+    "Baustein": { "@id": "vvo:Baustein", "@type": "@id" },
+    "Parent": { "@id": "vvo:Parent", "@type": "@id" }
+  }
+}

api-definition/src/main/resources/vocab.jsonld

@@ -0,0 +1,114 @@
+{
+  "@context": {
+    "hydra": "http://www.w3.org/ns/hydra/core#",
+    "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+    "xsd": "http://www.w3.org/2001/XMLSchema#",
+    "schema": "http://schema.org/",
+    "api": "https://bureau.kapdion.com/produktwissen-app/produktApi/vocab#",
+    "vvo": "http://vvo.pisanoapi.at/"
+  },
+  "@id": "api:ApiDocumentation",
+  "@type": "hydra:ApiDocumentation",
+  "hydra:title": "Produkt API",
+  "hydra:entrypoint": "https://bureau.kapdion.com/produktwissen-app/produktApi",
+  "hydra:supportedClass": [
+    {
+      "@id": "api:EntryPoint",
+      "@type": "hydra:Class",
+      "hydra:title": "API Einstiegspunkt",
+      "hydra:supportedOperation": [
+        {
+          "@id": "api:Produktwissen",
+          "@type": "hydra:Operation",
+          "hydra:method": "POST",
+          "hydra:title": "Produktwissen abfragen",
+          "hydra:expects": "api:ProductsRequest",
+          "hydra:returns": "api:ProductsResponse",
+          "hydra:possibleStatus": [
+            { "hydra:statusCode": 200, "description": "Produktwissen erfolgreich abgefragt" }
+          ]
+        },
+        {
+          "@id": "api:Calculate",
+          "@type": "hydra:Operation",
+          "hydra:method": "POST",
+          "hydra:title": "Berechnung ausführen",
+          "hydra:expects": "api:CalculateRequest",
+          "hydra:returns": "api:CalculateResponse",
+          "hydra:possibleStatus": [
+            { "hydra:statusCode": 200, "description": "Berechnung durchgeführt" }
+          ]
+        }
+      ]
+    },
+    {
+      "@id": "api:ProductsRequest",
+      "@type": "hydra:Class",
+      "hydra:title": "Produktanfrage",
+      "hydra:supportedProperty": [
+        {
+          "hydra:property": "api:stichtag",
+          "hydra:title": "Stichtag für die Abfrage",
+          "hydra:required": true,
+          "range": "xsd:date"
+        }
+      ]
+    },
+    {
+      "@id": "api:CalculateRequest",
+      "@type": "hydra:Class",
+      "hydra:title": "Berechnungsanfrage",
+      "hydra:supportedProperty": [
+        { "hydra:property": "vvo:ProdElement" },
+        { "hydra:property": "vvo:Meldung" },
+        { "hydra:property": "vvo:FahrzeugType" }
+
+
+      ]
+    },
+    {
+      "@id": "api:ProductsResponse",
+      "@type": "hydra:Class",
+      "hydra:title": "Antwort der Produktwissen-Abfrage",
+      "hydra:supportedProperty": [
+        { "hydra:property": "vvo:ProdElement" },
+        { "hydra:property": "vvo:Meldung" }
+      ]
+    },
+    {
+      "@id": "api:CalculateResponse",
+      "@type": "hydra:Class",
+      "hydra:title": "Antwort der Berechnung",
+      "hydra:supportedProperty": [
+        { "hydra:property": "vvo:ProdElement" },
+        { "hydra:property": "vvo:Meldung" }
+      ]
+    },
+    {
+      "@id": "vvo:ProdElement",
+      "@type": "hydra:Class",
+      "hydra:title": "VVO Produkt-Element",
+      "hydra:description": "Ein Element innerhalb der Versicherungsstruktur (Baustein, Elementarprodukt etc.)",
+      "hydra:supportedProperty": [
+        { "hydra:property": "vvo:bez", "hydra:title": "Bezeichnung" },
+        { "hydra:property": "vvo:value", "hydra:title": "Wert" },
+        { "hydra:property": "vvo:minOccurrence", "hydra:title": "Minimale Häufigkeit" },
+        { "hydra:property": "vvo:maxOccurrence", "hydra:title": "Maximale Häufigkeit" },
+        { "hydra:property": "vvo:Baustein", "hydra:title": "Referenz auf Unterbausteine" },
+        { "hydra:property": "vvo:Parent", "hydra:title": "Referenz auf Elternelement" }
+      ]
+    },
+    {
+      "@id": "vvo:Meldung",
+      "@type": "hydra:Class",
+      "hydra:title": "System-Meldung",
+      "hydra:supportedProperty": [
+        { "hydra:property": "vvo:errorMsg", "hydra:title": "Fehlermeldung Text" },
+        { "hydra:property": "vvo:errorType", "hydra:title": "Fehlertyp Code" }
+      ]
+    }
+
+    //To-Do: Genauer ausformulieren
+  ]
+}

client-app/pom.xml

@@ -23,6 +23,33 @@
       <artifactId>client-lib</artifactId>
       <version>${project.version}</version>
     </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.openjfx/javafx-controls -->
+      <!-- GPLv2+CE License https://openjdk.java.net/legal/gplv2+ce.html-->
+      <groupId>org.openjfx</groupId>
+      <artifactId>javafx-controls</artifactId>
+      <version>23.0.1</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.controlsfx/controlsfx -->
+      <!-- The 3-Clause BSD License http://www.opensource.org/licenses/bsd-license.php -->
+      <groupId>org.controlsfx</groupId>
+      <artifactId>controlsfx</artifactId>
+      <version>11.2.2</version>
+    </dependency>
   </dependencies>
 
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.openjfx</groupId>
+        <artifactId>javafx-maven-plugin</artifactId>
+        <version>0.0.8</version>
+        <configuration>
+          <mainClass>at.vvo.omds.client.gui.MainView</mainClass>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
 </project>

client-app/src/main/java/at/vvo/omds/client/BuildRequestHelper.java

@@ -0,0 +1,130 @@
+package at.vvo.omds.client;
+
+import at.vvo.omds.types.omds2.v2_17.NATUERLICHEPERSONType;
+import at.vvo.omds.types.omds2.v2_17.PersArtCdType;
+import at.vvo.omds.types.omds3.r2025_05.common.AdresseType;
+import at.vvo.omds.types.omds3.r2025_05.common.ObjektIdType;
+import at.vvo.omds.types.omds3.r2025_05.common.PersonType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+/**
+ * Hilfsmethoden für die Erzeugung von Requests.
+ */
+public class BuildRequestHelper {
+
+    static Logger log = LoggerFactory.getLogger(BuildRequestHelper.class);
+    /** Privater default Constructor versteckt den nicht benötigten Default-Constructor. */
+    private BuildRequestHelper() {
+    }
+
+    public static XMLGregorianCalendar omdsDatum(int year, int month, int day) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd");
+        try {
+            GregorianCalendar c = new GregorianCalendar();
+            c.set(year, month, day);
+            return DatatypeFactory.newInstance().newXMLGregorianCalendar(c.toZonedDateTime().format(formatter));
+        } catch (DatatypeConfigurationException e) {
+            log.atError().log("Datum konnte nicht erzeugt werden");
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static XMLGregorianCalendar aktuellesDatum() {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss");
+        try {
+            GregorianCalendar c = new GregorianCalendar();
+            return DatatypeFactory.newInstance().newXMLGregorianCalendar(c.toZonedDateTime().format(formatter));
+        } catch (DatatypeConfigurationException e) {
+            log.atError().log("Datum konnte nicht erzeugt werden");
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static XMLGregorianCalendar zuXml(LocalDate localDate) {
+        XMLGregorianCalendar xmlGregorianCalendar = null;
+        try {
+            xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(localDate.toString());
+        } catch (DatatypeConfigurationException e) {
+            log.atError().log(String.format("DatatypeConfigurationException %s", e.getMessage()));
+        }
+        return xmlGregorianCalendar;
+    }
+
+    public static XMLGregorianCalendar hauptfalligkeit(int monat) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss");
+        try {
+            GregorianCalendar c = new GregorianCalendar();
+            c.set(Calendar.MONTH, monat);
+            c.set(Calendar.DAY_OF_MONTH, 1);
+            c.set(Calendar.HOUR_OF_DAY, 0);
+            c.set(Calendar.MINUTE, 0);
+            c.set(Calendar.SECOND, 0);
+            c.set(Calendar.MILLISECOND, 0);
+            return DatatypeFactory.newInstance().newXMLGregorianCalendar(c.toZonedDateTime().format(formatter));
+        } catch (DatatypeConfigurationException e) {
+            log.atError().log("Datum konnte nicht erzeugt werden");
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static PersonType createNatPerson(String vorname, String nachname, LocalDate gebDat, String strasse, String hausnr, int plz, String ort) {
+        PersonType person = new PersonType();
+
+        person.setPersArtCd(PersArtCdType.N);   //neu
+        NATUERLICHEPERSONType natPerson = new NATUERLICHEPERSONType();
+        natPerson.setFamilienname(nachname);
+        natPerson.setVorname(vorname);
+        natPerson.setGebdat(BuildRequestHelper.zuXml(gebDat));
+        natPerson.setGeschlechtCd("1");
+        natPerson.setFamilienstandCd("0");  // neu
+        natPerson.setLandesCd("AUT");       // neu
+        person.setNATUERLICHEPERSON(natPerson);
+        AdresseType adresse = new AdresseType();
+        person.setAdresse(adresse);
+        adresse.setOrt(ort);
+        adresse.setPLZ(Integer.toString(plz));
+        adresse.setStrasse(strasse);
+        adresse.setHausnr(hausnr);
+        adresse.setLandesCd("AUT");         //neu
+        ObjektIdType objektId = new ObjektIdType(); //neu
+        objektId.setId("1");                        //neu
+        adresse.setObjektId(objektId);              //neu
+        return person;
+    }
+
+    public static PersonType createNatPerson(String vorname, String nachname, int gebJahr, int gebMonat, int gebTag) {
+        PersonType person = new PersonType();
+
+        person.setPersArtCd(PersArtCdType.N);   //neu
+        NATUERLICHEPERSONType natPerson = new NATUERLICHEPERSONType();
+        natPerson.setFamilienname(nachname);
+        natPerson.setVorname(vorname);
+        natPerson.setGebdat(BuildRequestHelper.omdsDatum(gebJahr, gebMonat, gebTag));
+        natPerson.setGeschlechtCd("1");
+        natPerson.setFamilienstandCd("0");  // neu
+        natPerson.setLandesCd("AUT");       // neu
+        person.setNATUERLICHEPERSON(natPerson);
+        AdresseType adresse = new AdresseType();
+        person.setAdresse(adresse);
+        adresse.setOrt("Wien");
+        adresse.setPLZ("1020");
+        adresse.setStrasse("Schüttelstraße");
+        adresse.setHausnr("99");
+        adresse.setZusatz("7");
+        adresse.setLandesCd("AUT");         //neu
+        ObjektIdType objektId = new ObjektIdType(); //neu
+        objektId.setId("1");                        //neu
+        adresse.setObjektId(objektId);              //neu
+
+        return person;
+    }
+
+}

client-app/src/main/java/at/vvo/omds/client/LogCalculateResponse.java

@@ -0,0 +1,44 @@
+package at.vvo.omds.client;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.CalculateUnfallResponseType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class LogCalculateResponse {
+
+    public static void ausgabe(CalculateUnfallResponseType response) {
+        Logger logger = LoggerFactory.getLogger(LogCalculateResponse.class);
+        logger.info("Got Response As below ================================== : ");
+        logger.info("Status : "+response.getStatus().getErgebnis().value());
+        logger.info("KorrelationsId : "+response.getStatus().getKorrelationsId());
+        logger.info("Personen =============================================== : ");
+        logger.info("Anzahl-Personen : "+response.getBerechnungsantwort().getPersonen().size());
+        for (int i=0; i<response.getBerechnungsantwort().getPersonen().size(); i++) {
+            logger.info("Person-" + (i+1));
+            if (response.getBerechnungsantwort().getPersonen().get(i).getPerson().getNATUERLICHEPERSON() != null) {
+                logger.info("Natürliche Person : ");
+                logger.info("Familienname : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getNATUERLICHEPERSON().getFamilienname());
+                logger.info("Vorname : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getNATUERLICHEPERSON().getVorname());
+                logger.info("Geburtsdatum : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getNATUERLICHEPERSON().getGebdat());
+            }else {
+                logger.info("Sonstige Person : ");
+                logger.info("Name : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getSONSTIGEPERSON().getName());
+                logger.info("Kurzname : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getSONSTIGEPERSON().getKurzname());
+                logger.info("Kurzname : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getSONSTIGEPERSON().getSonstPersArtCd());
+            }
+            logger.info("Plz Ort : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getAdresse().getPLZ() + " " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getAdresse().getOrt());
+            logger.info("Anschrift : " + response.getBerechnungsantwort().getPersonen().get(i).getPerson().getAdresse().getStrasse() + " " +
+                    response.getBerechnungsantwort().getPersonen().get(i).getPerson().getAdresse().getHausnr() + "/" +
+                    response.getBerechnungsantwort().getPersonen().get(i).getPerson().getAdresse().getZusatz());
+        }
+        logger.info("Verkaufsprodukt ======================================== : ");
+        logger.info("Produktvariante : " + response.getBerechnungsantwort().getVerkaufsprodukt().getId());
+        logger.info("Vertragsbeginn : " + response.getBerechnungsantwort().getVerkaufsprodukt().getVtgBeg());
+        logger.info("Vertragsende : " + response.getBerechnungsantwort().getVerkaufsprodukt().getVtgEnde());
+        logger.info("Vermittlernummer : " + response.getBerechnungsantwort().getVerkaufsprodukt().getVermittlernr());
+        logger.info("Hauptfaelligkeit : " + response.getBerechnungsantwort().getVerkaufsprodukt().getHauptfaelligkeit());
+        logger.info("Zahlrhythmus : " + response.getBerechnungsantwort().getVerkaufsprodukt().getZahlrhythmus());
+
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/FehlerDefinitionen.md

@@ -0,0 +1,70 @@
+# Verhalten Server und Client
+
+### Prämissen
+* Request kann immer vollkommen "dirty" sein, über Kaskade von Prüfungen muss dies validiert werden.
+* Immer gültiges XML
+* Aufbau des Requests entspricht dem a priori Produktwissen. Wenn dagegen verstoßen wird (Baustein oder Attribut), gibt es
+möglichst sprechende Fehlermeldungen. Es ist aber ein Fehler zur Entwicklungszeit, d.h. es darf aber es muss keinen Produktbaum im
+Response geben, einfache Fehlermeldung genügt. Es ist kein inhaltlicher Konfigurationsfehler, der über einen "schönen"
+Response an den Client zur Korrektur gegeben werden muss.
+* Response darf teilweise "dirty" sein, damit gute Fehlerhinweise möglich sind und der User leicht korrigieren kann.
+* Client zeigt den Response an und keine Mischung aus seinem Request und dem Response. Damit
+  Client und Server wieder synchron sind.
+* Das Verhalten könnte Context-gesteuert sein, z.B.: 
+  * Im Context "Produktvergleich" werden immer nur Fehlermeldungen geworfen
+  * Im Context "Antrag", "Vertragsänderung" oder "Einzelkonfiguration" werden Empfehlungen abgegeben.
+* Das Verhalten des Servers könnte sogar Produktabhängig definiert sein: An manchen Bausteinen Variante 1 an
+anderen Variante 2 des Verhaltens.(?)
+* Berechnung nur, wenn die Instanz (Antrag, Vertrag) erfolgreich plausibilisiert.
+* Unterstützung für "Actions"?
+* Verhaltenssteuerung: Im Request kann ein Profil vorgegeben werden. Im Response wird angegeben, ob es berücksichtigt werden konnte, oder Fallbackverhalten.
+  * Basic - nur Fehlermeldungen, Baum wird nie verändert
+  * Advanced - Fehlermeldungen und Änderungen im Baum (z.B. Anlage von Default-Elementen). Das Verhalten im Baum ist normiert.
+  * Freestyle - Server reagiert innerhalb der vorgegebenen Möglichkeiten, wie er es an der Stelle für richtig hält. Sprich der
+    Produktentwickler legt dies fest und kann das für Bausteine und Attribute festlegen.
+  * Actions - es werden Actions angeboten, um Korrekturen im Baum vorzunehmen. 
+  
+## Fälle Bausteine
+
+Der Client schickt einen Unbekannten Baustein. Der Server gibt eine Fehlermeldung zurück.
+Der Client schickt einen Baustein mit einem fehlerhaften Attribut. Der Server gibt eine Fehlermeldung zurück.
+Der Server schickt einen ungültigen Baustein. Der Server gibt eine Fehlermeldung zurück.
+
+
+Der Client schickt zu viele von einem Baustein. A priori erstmal ausgeschlossen, da der  
+Client über Produktwissen verfügt. Über Plausis in der Instanz kann der Fall trotzdem eintreten.
+Der Server könnte:
+1) Fehlermeldung in Oberbaustein senden
+2) Die überzähligen Bausteine auf Inaktiv setzen und mit Fehler markieren
+3) Den überzähligen Baustein / die überzähligen Bausteine entfernen
+
+Der Client schickt zu wenig von einem Baustein. Der Server könnte:
+1) Einen Default Baustein (mehrere Default-Bausteine) hinzufügen (er kann dabei die Daten des Requests in den 
+Vorschlag einfließen lassen, was der Client nicht kann)
+2) Eine Meldung über den Parent mitgeben, der Client ist dann zuständig den Baustein anzulegen.
+
+Der Client schickt Bausteine, die sich wiedersprechen. Der Server könnte:
+1) Fehlermeldung und beide belassen
+2) Fehlermeldung und einen priorisieren und den anderen inaktiv setzen.
+3) Fehlermeldung und beide inaktiv setzen
+
+Der Client schickt einen Baustein in einem falschen Kontext. Der Server könnte:
+1) Den Baustein dem richtigen Kontext zuordnen
+2) Den Baustein inaktiv setzen
+
+
+## Fälle Attribute
+
+Attribut unbekannt - sollte gar nicht auftreten, muss nicht inhaltlich behandelt werden
+
+Wert in Attribut ungültig - Attribut behält den falschen Wert, wird aber mit Fehlermeldung zurückgegeben.
+
+Kardinalität Attribut überschritten: 
+1) Fehler an Baustein
+2) Fehler an überzähligen Attributen
+
+Kardinalität Attribut unterschritten:
+1) Fehler an Baustein aber keine automatische Ergänzung
+2) Hinweis an Baustein, Ergänzen der fehlenden Attribute mit Defaultwerten.
+
+

client-app/src/main/java/at/vvo/omds/client/gui/ItemAttribute.java

@@ -0,0 +1,427 @@
+package at.vvo.omds.client.gui;
+
+import at.vvo.omds.helpers.GuiProdukt;
+import at.vvo.omds.types.omds3.r2025_05.common.*;
+import javafx.animation.PauseTransition;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.control.*;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontWeight;
+import javafx.scene.text.Text;
+import javafx.util.Duration;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+public class ItemAttribute {
+    Map<TreeItem<GuiProdukt>, Map<AttributType, String>> infoBoxFromItem = new HashMap<>();
+    List<VersichertesInteresseMitAttributMetadatenType> risikoobjekte = new ArrayList<>();
+
+    public List<VersichertesInteresseMitAttributMetadatenType> getRisikoobjekte() {
+        return risikoobjekte;
+    }
+
+    public void setRisikoobjekte(List<VersichertesInteresseMitAttributMetadatenType> risikoobjekte) {
+        this.risikoobjekte = risikoobjekte;
+    }
+
+    public Map<TreeItem<GuiProdukt>, Map<AttributType, String>> getInfoBoxFromItem() {
+        return infoBoxFromItem;
+    }
+    public void setInfoBoxFromItem(Map<TreeItem<GuiProdukt>, Map<AttributType, String>> infoBoxFromItem) {
+        this.infoBoxFromItem = infoBoxFromItem;
+    }
+
+    public VBox addItemInfo(TreeItem<GuiProdukt> newSelection, VBox attributBox) {
+        for(int j = 0; j < ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().size(); j++) {
+            VBox singleAttributBox = new VBox();
+            singleAttributBox.setPadding(new Insets(10));
+
+            Label label = new Label(
+                    ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j).getBezeichnung() + ": ");
+            label.setId("label");
+            TextField textField = new TextField();
+
+            CheckBox checkBox = new CheckBox();
+
+            AttributStringType stringAttribut;
+            AttributBooleanType attributBoolean;
+            AttributDezimalType attributDezimal;
+            AttributIntType attributInt;
+
+            if (((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j).getClass()
+                    .equals(AttributBooleanType.class)) {
+                attributDezimal = null;
+                attributInt = null;
+                stringAttribut = null;
+
+                attributBoolean = (AttributBooleanType) (
+                        (ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j);
+
+                if (infoBoxFromItem.get(newSelection) != null && infoBoxFromItem.get(newSelection).get(attributBoolean)
+                        != null && !infoBoxFromItem.get(newSelection).get(attributBoolean).isEmpty()){
+                    if (infoBoxFromItem.get(newSelection).get(attributBoolean).equals("false")){
+                        checkBox.setSelected(false);
+                    }else if(infoBoxFromItem.get(newSelection).get(attributBoolean).equals("true")){
+                        checkBox.setSelected(true);
+                    }
+                }
+            } else if (((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j).getClass()
+                    .equals(AttributStringType.class)) {
+                attributDezimal = null;
+                attributBoolean = null;
+                attributInt = null;
+
+                stringAttribut = (AttributStringType) ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j);
+
+                if (stringAttribut.isPflichtfeld()) {
+                    label.setText(label.getText().substring(0, label.getText().length()-2) + "*: ");
+                }
+                if (stringAttribut.isAenderbar() != null && !stringAttribut.isAenderbar()) {
+                    textField.setEditable(false);
+                }
+                if (infoBoxFromItem.get(newSelection) != null
+                        && infoBoxFromItem.get(newSelection).get(stringAttribut) != null
+                        && !infoBoxFromItem.get(newSelection).get(stringAttribut).isEmpty()){
+                    textField.setText(infoBoxFromItem.get(newSelection).get(stringAttribut));
+                } else if (stringAttribut.getValue() != null && !stringAttribut.getValue().equals("null")) {
+                    textField.setText(stringAttribut.getValue());
+                } else if (stringAttribut.getDefault() != null) {
+                    textField.setText(stringAttribut.getDefault());
+                }
+                textField.setPromptText("Text eingeben");
+
+            } else if (((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j).getClass()
+                    .equals(AttributDezimalType.class)) {
+                attributBoolean = null;
+                attributInt = null;
+                stringAttribut = null;
+
+                attributDezimal = (AttributDezimalType) ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j);
+
+                if (attributDezimal.isPflichtfeld()) {
+                    label.setText(label.getText().substring(0, label.getText().length()-2) + "*: ");
+                }
+                if (attributDezimal.isAenderbar() != null && !attributDezimal.isAenderbar()) {
+                    textField.setEditable(false);
+                }
+                if (infoBoxFromItem.get(newSelection) != null
+                        && infoBoxFromItem.get(newSelection).get(attributDezimal) != null
+                        && !infoBoxFromItem.get(newSelection).get(attributDezimal).isEmpty()){
+                    textField.setText(infoBoxFromItem.get(newSelection).get(attributDezimal));
+                } else if (attributDezimal.getValue() != null && !(attributDezimal.getValue().toString().equals("-1"))) {
+                    textField.setText(attributDezimal.getValue().toString());
+                } else if (attributDezimal.getDefault() != null) {
+                    textField.setText(attributDezimal.getDefault().toString());
+                }
+                textField.setPromptText("Dezimalzahl eingeben");
+            } else {
+                attributDezimal = null;
+                attributBoolean = null;
+                stringAttribut = null;
+
+                attributInt = (AttributIntType) ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().get(j);
+
+                if (attributInt.isPflichtfeld()) {
+                    label.setText(label.getText().substring(0, label.getText().length()-2) + "*: ");
+                }
+                if (attributInt.isAenderbar() != null && !attributInt.isAenderbar()) {
+                    textField.setEditable(false);
+                }
+                if (infoBoxFromItem.get(newSelection) != null
+                        && infoBoxFromItem.get(newSelection).get(attributInt) != null
+                        && !infoBoxFromItem.get(newSelection).get(attributInt).isEmpty()){
+                    textField.setText(infoBoxFromItem.get(newSelection).get(attributInt));
+                } else if (attributInt.getValue() != null && !attributInt.getValue().equals(-1)) {
+                    textField.setText(attributInt.getValue().toString());
+                } else if (attributInt.getDefault() != null) {
+                    textField.setText(attributInt.getDefault().toString());
+                }
+                textField.setPromptText("Ganzzahl eingeben");
+            }
+
+            if (attributBoolean != null && attributBoolean.isValue() != null) {
+                checkBox.setSelected(attributBoolean.isValue());
+            }else if(attributBoolean != null && attributBoolean.isDefault() != null) {
+                checkBox.setSelected(attributBoolean.isDefault());
+            }
+
+            if (attributBoolean != null && attributBoolean.isAenderbar() != null && !attributBoolean.isAenderbar()) {
+                checkBox.setDisable(true);
+            }
+            if (attributBoolean != null && attributBoolean.isPflichtfeld()) {
+                label.setText(label.getText().substring(0, label.getText().length()-2) + "*: ");
+            }
+
+            int finalJ = j;
+            checkBox.selectedProperty().addListener((obsVal, oldVal, newVal) -> {
+                if (attributBoolean != null) {
+                    infoBoxFromItem.computeIfAbsent(newSelection,
+                            k -> new HashMap<>()).put(attributBoolean, checkBox.isSelected() ? "true" : "false");
+                    attributBoolean.setValue(checkBox.isSelected());
+                    ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().set(finalJ, attributBoolean);
+                }
+            });
+            textField.focusedProperty().addListener((observableValue, oldVal, newVal) -> {
+                if (!newVal) {
+                    PauseTransition pause = new PauseTransition(Duration.seconds(3));
+                    pause.setOnFinished(ep -> {
+                        textField.setStyle("-fx-border-color: #bfbfbf");
+                    });
+                    if (attributDezimal != null){
+                        infoBoxFromItem.computeIfAbsent(newSelection,
+                                k -> new HashMap<>()).put(attributDezimal, textField.getText());
+
+                        String eingabe = textField.getText().replace(",",".");
+                        if (textField.getText().isEmpty()){
+                            if (attributDezimal.isPflichtfeld()){
+
+                                Label failedCheck = new Label("Es muss ein Wert mitgegeben werden");
+                                failedCheck.setVisible(true);
+                                failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+
+                                textField.setStyle("-fx-border-color: #dd0000");
+
+                                pause.play();
+
+                                if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                                singleAttributBox.getChildren().addLast(failedCheck);
+                            }
+                        } else if(!textField.getText().matches("^-?[0-9]+[,.]?[0-9]*")){
+                            Label failedCheck = new Label("Der Wert muss einer Dezimal Zahl entsprechen ");
+                            failedCheck.setVisible(true);
+                            failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+
+                            textField.setStyle("-fx-border-color: #dd0000");
+                            pause.play();
+
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            singleAttributBox.getChildren().addLast(failedCheck);
+                        } else if (new BigDecimal(eingabe).compareTo(attributDezimal.getMin()) < 0 ||
+                                new BigDecimal(eingabe).compareTo(attributDezimal.getMax()) > 0) {
+                            Label failedCheck = new Label("Der Wert muss zwischen "
+                                    + attributDezimal.getMin() + " und " + attributDezimal.getMax() + " liegen");
+                            failedCheck.setVisible(true);
+                            failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+
+                            textField.setStyle("-fx-border-color: #dd0000");
+                            pause.play();
+
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            singleAttributBox.getChildren().addLast(failedCheck);
+                        }else {
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            attributDezimal.setValue(new BigDecimal(eingabe));
+                            ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().set(finalJ, attributDezimal);
+                        }
+                    } else if (attributInt != null) {
+                        infoBoxFromItem.computeIfAbsent(newSelection,
+                                k -> new HashMap<>()).put(attributInt, textField.getText());
+
+                        if (textField.getText() == null || textField.getText().isEmpty()
+                                || !textField.getText().matches("^-?[0-9]*")) {
+                            Label failedCheck = new Label("Es muss ein ganzzahliger Wert eingegeben werden");
+                            failedCheck.setVisible(true);
+                            failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+
+                            textField.setStyle("-fx-border-color: #dd0000");
+                            pause.play();
+
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            singleAttributBox.getChildren().addLast(failedCheck);
+                        }else if (Integer.parseInt(textField.getText()) < attributInt.getMin()
+                                || Integer.parseInt(textField.getText()) > attributInt.getMax()) {
+                            Label failedCheck = new Label("Der Wert muss zwischen " + attributInt.getMin()
+                                    + " und " + attributInt.getMax() + " liegen");
+                            failedCheck.setVisible(true);
+                            failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+
+                            textField.setStyle("-fx-border-color: #dd0000");
+                            pause.play();
+
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            singleAttributBox.getChildren().addLast(failedCheck);
+                        }else {
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            attributInt.setValue(Integer.parseInt(textField.getText()));
+                            ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().set(finalJ, attributInt);
+                        }
+                    } else if (stringAttribut != null) {
+                        infoBoxFromItem.computeIfAbsent(newSelection,
+                                k -> new HashMap<>()).put(stringAttribut, textField.getText());
+
+                        if (textField.getText() == null ||
+                                (stringAttribut.getMinLaenge() != null
+                                        && textField.getText().length() < stringAttribut.getMinLaenge()) ||
+                                (stringAttribut.getMaxLaenge() != null
+                                        && textField.getText().length() > stringAttribut.getMaxLaenge()) ||
+                                (stringAttribut.getRegex() != null
+                                        && !textField.getText().matches(stringAttribut.getRegex()))) {
+                            Label failedCheck = new Label("Der Wert muss zwischen " +
+                                    stringAttribut.getMinLaenge() + " und " + stringAttribut.getMaxLaenge() +
+                                    (stringAttribut.getRegex() != null ? " Buchstaben haben und der Form " +
+                                            stringAttribut.getRegex() + " entsprechen" : "Buchstaben haben"));
+                            failedCheck.setVisible(true);
+                            failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+
+                            textField.setStyle("-fx-border-color: #dd0000");
+                            pause.play();
+
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().set(finalJ, attributInt);
+
+                        }else {
+                            if (singleAttributBox.getChildren().size() > 2) singleAttributBox.getChildren().removeLast();
+                            stringAttribut.setValue(textField.getText());
+                            ((ProduktbausteinType)newSelection.getValue().getProdukt()).getAttribute().set(finalJ, stringAttribut);
+                        }
+                    }
+
+                }
+            });
+            if (attributBoolean != null) {
+                singleAttributBox.getChildren().addAll(label, checkBox);
+            }else {
+                textField.setId("textField");
+                singleAttributBox.getChildren().addAll(label, textField);
+            }
+
+            singleAttributBox.setId("singleAttributBox");
+
+            attributBox.getChildren().add(singleAttributBox);
+        }
+
+        if (((ProduktbausteinType) newSelection.getValue().getProdukt()).isRisikoobjektErforderlich()) {
+
+            VBox risikoobjektAuswahlBox = new VBox();
+            Label vpRo = new Label("Mit dem Baustein assoziierte Risikoobjekte: ");
+
+            for (int i = 0; i < risikoobjekte.size(); i++) {
+                CheckBox checkBox = new CheckBox();
+                checkBox.setText(risikoobjekte.get(i).toString());
+
+                if (risikoobjekte.get(i) instanceof FahrzeugType) {
+                    checkBox.setText(((FahrzeugType) risikoobjekte.get(i)).getHandelsbez() + " ("
+                            + ((FahrzeugType) risikoobjekte.get(i)).getBaujahr() + ")");
+
+                    int finalI = i;
+
+                    if (((ProduktbausteinType) newSelection.getValue().getProdukt()).getVersicherteObjekte()
+                            .stream().anyMatch(v -> ((FahrzeugType) v).getHandelsbez()
+                                    .equals(((FahrzeugType) risikoobjekte.get(finalI)).getHandelsbez()))) {
+                        checkBox.setSelected(true);
+                    }
+
+                    checkBox.selectedProperty().addListener((observableValue, oldValue, newValue) -> {
+                        if (newValue) {
+                            ((ProduktbausteinType) newSelection.getValue().getProdukt()).getVersicherteObjekte().add(risikoobjekte.get(finalI));
+                        } else {
+                            ((ProduktbausteinType) newSelection.getValue().getProdukt()).getVersicherteObjekte().remove(finalI);
+                        }
+                    });
+                }
+                risikoobjektAuswahlBox.getChildren().add(checkBox);
+            }
+
+            risikoobjektAuswahlBox.getChildren().addFirst(vpRo);
+            risikoobjektAuswahlBox.setPadding(new Insets(10));
+            risikoobjektAuswahlBox.setId("risikoobjektAuswahlBox");
+
+            attributBox.getChildren().removeIf(c -> c.getId() != null && c.getId().equals("risikoobjektAuswahlBox"));
+            attributBox.getChildren().add(risikoobjektAuswahlBox);
+        }
+
+        return addFaultsInfo((ProduktbausteinType) newSelection.getValue().getProdukt(), attributBox);
+    }
+
+    public VBox addFaultsInfo(ProduktbausteinType produktbaustein, VBox attributBox) {
+        if (produktbaustein.getMeldungen() != null && !produktbaustein.getMeldungen().isEmpty()) {
+            attributBox.getChildren().removeIf(n -> n.getId() != null && n.getId().equals("faultsbox"));
+            VBox faultsBox = new VBox();
+            faultsBox.setId("faultsbox");
+
+            for (ServiceFault sf : produktbaustein.getMeldungen()) {
+                HBox singleFaultBox = new HBox();
+
+                Text symbole = new Text("\u26A0 ");
+                symbole.setFont(Font.font("System", FontWeight.BOLD, symbole.getFont().getSize() + 2));
+
+                if (sf.getErrorType().equals(BigInteger.ONE)) {
+                    symbole.setFill(Paint.valueOf("#aa3333"));
+                } else if (sf.getErrorType().equals(BigInteger.TWO)) {
+                    symbole.setFill(Paint.valueOf("#ccbb00"));
+                }
+                Label errorText = new Label(sf.getErrorMsg() + System.lineSeparator());
+                errorText.setId("errorText");
+
+                singleFaultBox.getChildren().addAll(symbole, errorText);
+                singleFaultBox.setId("singleFaultBox");
+                faultsBox.getChildren().add(singleFaultBox);
+            }
+
+            if (!faultsBox.getChildren().isEmpty()) {
+                if (produktbaustein.getAttribute().isEmpty()) {
+                    attributBox.getChildren().addAll(faultsBox);
+                }else {
+                    List<Node> singleAttributBoxes = attributBox.getChildren().stream().filter(n -> n.getId() != null && n.getId().equals("singleAttributBox")).toList();
+                    Optional<Node> textField;
+                    Optional<Node> label;
+                    for (Node singleAttributBox : singleAttributBoxes) {
+                        textField = ((VBox)singleAttributBox).getChildren().stream().filter(n -> n.getId() != null && n.getId().equals("textField")).findFirst();
+                        label = ((VBox)singleAttributBox).getChildren().stream().filter(n -> n.getId() != null && n.getId().equals("label")).findFirst();
+                        List<Node> singleFaultBoxes = faultsBox.getChildren().stream().filter(n -> n.getId() != null && n.getId().equals("singleFaultBox")).toList();
+
+                        if (textField.isPresent() && label.isPresent()) {
+
+                            for (Node singleFaultBox : singleFaultBoxes) {
+                                Optional<Node> errorText = ((HBox)singleFaultBox).getChildren().stream().filter(c -> c.getId() != null && c.getId().equals("errorText")).findFirst();
+
+                                if (errorText.isPresent() && ((Label)errorText.get()).getText().contains(((Label)label.get()).getText().replace(":","").replace("*",""))) {
+                                    textField.get().setStyle("-fx-border-color: #dd0000");
+                                    ((VBox)singleAttributBox).getChildren().addLast(faultsBox);
+                                    Optional<Node> finalTextField = textField;
+                                    textField.get().focusedProperty().addListener(s -> finalTextField.get().setStyle(null));
+
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return attributBox;
+    }
+
+    public VBox addVpInfo(VBox attributBox, boolean meldungVorhanden, VerkaufsproduktType vp) {
+        attributBox.getChildren().removeIf(c -> c.getId() != null && c.getId().equals("vpLabel"));
+
+        Label vpLabel = new Label();
+        if (!meldungVorhanden) {
+            vpLabel.setText("Gültiges Verkaufsprodukt " + System.lineSeparator());
+        }else {
+            vpLabel.setText("Kein Gültiges Verkaufsprodukt " + System.lineSeparator());
+        }
+        vpLabel.setPadding(new Insets(10));
+        attributBox.getChildren().addFirst(vpLabel);
+
+
+//        VBox vpMeldungenTexts = new VBox();
+//        vp.getMeldungen().forEach( m -> {
+//            Label vpMeldungText = new Label(m.getErrorMsg() + System.lineSeparator());
+//            vpMeldungText.setPadding(new Insets(10));
+//
+//            vpMeldungenTexts.getChildren().add(vpMeldungText);
+//        });
+
+        attributBox.getChildren().removeIf(c -> c.getId() != null && c.getId().equals("vpMeldungenTexts"));
+//        attributBox.getChildren().addAll(vpMeldungenTexts);
+
+        return attributBox;
+    }
+
+}

client-app/src/main/java/at/vvo/omds/client/gui/MainView.java

@@ -0,0 +1,711 @@
+package at.vvo.omds.client.gui;
+
+import at.vvo.omds.client.gui.api.apriori.AprioriAuskunftService;
+import at.vvo.omds.client.gui.api.calc.CalculateRequestAuskunftService;
+import at.vvo.omds.client.gui.api.SOAPConnector;
+import at.vvo.omds.helpers.*;
+import at.vvo.omds.types.omds3.r2025_05.common.*;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.common.*;
+import com.sun.xml.messaging.saaj.SOAPExceptionImpl;
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.event.ActionEvent;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.*;
+import javafx.scene.image.Image;
+import javafx.scene.layout.*;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.*;
+import javafx.stage.Stage;
+import javafx.util.Pair;
+import org.controlsfx.control.ToggleSwitch;
+import org.eclipse.rdf4j.model.Model;
+import org.eclipse.rdf4j.query.GraphQuery;
+import org.eclipse.rdf4j.query.QueryResults;
+import org.eclipse.rdf4j.repository.Repository;
+import org.eclipse.rdf4j.repository.RepositoryConnection;
+import org.eclipse.rdf4j.repository.sail.SailRepository;
+import org.eclipse.rdf4j.rio.RDFFormat;
+import org.eclipse.rdf4j.rio.Rio;
+import org.eclipse.rdf4j.sail.memory.MemoryStore;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.io.ByteArrayOutputStream;
+import java.math.BigInteger;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class MainView extends Application {
+
+    Map<String, Integer> timesItemisIncludedById = new HashMap<>();
+    Map<TreeItem<GuiProdukt>, Map<AttributType, String>> infoBoxFromItem = new HashMap<>();
+    List<Plausi> plausiList = new ArrayList<>();
+
+    RisikoobjektView risikoobjektView = new RisikoobjektView();
+    TreeHelper treeHelper = new TreeHelper();
+    RDFHelper rdfHelper = new RDFHelper();
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+
+    @Override
+    public void start(Stage stage) {
+
+        stage.setTitle("OMDS Client");
+        stage.getIcons().add(new Image(MainView.class.getResourceAsStream("/logo/VVO_Logo_2024.png")));
+
+        TabPane tabPane = new TabPane();
+        Tab baumView = new Tab("Deckungsbaum");
+        Tab risikoView = new Tab("Risikoobjekte");
+
+        baumView.setClosable(false);
+        risikoView.setClosable(false);
+
+        tabPane.getTabs().addAll(baumView, risikoView);
+
+        BorderPane content = new BorderPane();
+        StackPane view = new StackPane();
+        GridPane risikoobjekt = risikoobjektView.risikoobjekte();
+        VBox deckungsbaum = deckungsbaum();
+
+        content.setTop(tabPane);
+        content.setCenter(view);
+
+        view.getChildren().addAll(risikoobjekt ,deckungsbaum);
+        risikoobjekt.setVisible(false);
+
+
+        tabPane.getSelectionModel().selectedItemProperty().addListener((obs, oldTab, newTab) -> {
+            if (newTab == risikoView) {
+                risikoobjekt.setVisible(true);
+                deckungsbaum.setVisible(false);
+            } else if (newTab == baumView) {
+                risikoobjekt.setVisible(false);
+                deckungsbaum.setVisible(true);
+            }
+        });
+
+        Scene scene = new Scene(content, 900, 600);
+        stage.setScene(scene);
+
+        stage.show();
+    }
+
+    public VBox deckungsbaum(){
+        AprioriAuskunftService s = new AprioriAuskunftService(new SOAPConnector());
+
+        final VBox[] controlBox = {new VBox()};
+        DatePicker dp = new DatePicker();
+        ChoiceBox<String> vpBox = new ChoiceBox<>();
+
+        vpBox.setValue("Verkaufsprodukt auswählen ");
+        vpBox.setVisible(false);
+        vpBox.setPadding(new Insets(0, 10, 0, 0));
+
+        AtomicReference<XMLGregorianCalendar> stichtag = new AtomicReference<>();
+        AtomicReference<ProductsResponse> response = new AtomicReference<>();
+        Button newCalcRequestButton = new Button("Calculate");
+        HBox newCalcRequestControlBox = new HBox();
+        newCalcRequestControlBox.setVisible(false);
+        newCalcRequestControlBox.setPadding(new Insets(10, 10, 10, 10));
+        newCalcRequestControlBox.getChildren().add(newCalcRequestButton);
+
+        HBox servBox = new HBox();
+        ToggleSwitch serverBtn = new ToggleSwitch("Benutze RDF Messaging");
+        serverBtn.setSelected(true);
+        serverBtn.setDisable(true);
+
+        AtomicReference<List<APrioriVerkaufsproduktType>> responseproduct = new AtomicReference<>(new ArrayList<>());
+
+        dp.setOnAction(e -> {
+            try {
+                stichtag.set(stichtagEvent(dp));
+                if (stichtagEvent(dp) != null) {
+                    try {
+                        Pair<List<APrioriVerkaufsproduktType>, List<Plausi>> aprioriPair = s.aprioriRDFAuskunft(stichtag.get(), "042");
+                        responseproduct.set(aprioriPair.getKey());
+                        plausiList = aprioriPair.getValue();
+
+                        newCalcRequestControlBox.setVisible(true);
+
+                        if (responseproduct.get().size() > 1) {
+                            if (!vpBox.getItems().isEmpty()) {
+                                vpBox.getItems().clear();
+                            }
+                            for (APrioriVerkaufsproduktType vp : responseproduct.get()) {
+                                vpBox.getItems().add(vp.getName());
+                            }
+                            vpBox.setVisible(true);
+                            vpBox.setOnAction(ee -> {
+                                for (int i = 0; i < responseproduct.get().size(); i++) {
+                                    if (vpBox.getSelectionModel().getSelectedItem() != null && vpBox.getSelectionModel()
+                                            .getSelectedItem().equals(responseproduct.get().get(i).getName())) {
+                                        try {
+                                            controlBox[0] = buttonAuskunft(responseproduct.get().get(i),
+                                                    controlBox[0], newCalcRequestButton, stichtag, serverBtn);
+                                            controlBox[0].getChildren().add(newCalcRequestControlBox);
+
+                                        } catch (Exception ex) {
+                                            throw new RuntimeException(ex);
+                                        }
+                                    }
+                                }
+                            });
+                        } else {
+                            controlBox[0] = buttonAuskunft(responseproduct.get().getFirst(),
+                                    controlBox[0], newCalcRequestButton, stichtag, serverBtn);
+                        }
+                    } catch (Exception rdfex) {
+                        serverBtn.setSelected(false);
+
+                        try {
+                            response.set(s.aprioriAuskunft(stichtag.get(), "042"));
+
+                            newCalcRequestControlBox.setVisible(true);
+                            if (response.get() != null && response.get().getVerkaufsprodukt().size() > 1) {
+
+                                if (!vpBox.getItems().isEmpty()) {
+                                    vpBox.getItems().clear();
+                                }
+                                for (APrioriVerkaufsproduktType vp : response.get().getVerkaufsprodukt()) {
+                                    vpBox.getItems().add(vp.getName());
+                                }
+                                vpBox.setVisible(true);
+                                vpBox.setOnAction(ee -> {
+                                    for (int i = 0; i < response.get().getVerkaufsprodukt().size(); i++) {
+                                        if (vpBox.getSelectionModel().getSelectedItem() != null && vpBox.getSelectionModel()
+                                                .getSelectedItem().equals(response.get().getVerkaufsprodukt().get(i).getName())) {
+                                            try {
+                                                controlBox[0] = buttonAuskunft(response.get().getVerkaufsprodukt().get(i),
+                                                        controlBox[0], newCalcRequestButton, stichtag, serverBtn);
+                                                controlBox[0].getChildren().add(newCalcRequestControlBox);
+
+                                            } catch (Exception ex) {
+                                                throw new RuntimeException(ex);
+                                            }
+                                        }
+                                    }
+                                });
+                            } else {
+                                controlBox[0] = buttonAuskunft(response.get().getVerkaufsprodukt().getFirst(),
+                                        controlBox[0], newCalcRequestButton, stichtag, serverBtn);
+                            }
+                        } catch (NoSuchElementException ex) {
+                            controlBox[0].getChildren().clear();
+                            controlBox[0].getChildren().add(dp);
+                            vpBox.getItems().clear();
+
+                            Label label = new Label("Kein Verkaufsoffenes Produkt an dem Datum: " +
+                                    stichtag.get().toString().substring(0, stichtag.get().toString().length() - 1) +
+                                    System.lineSeparator());
+                            controlBox[0].getChildren().add(3, label);
+                            throw new NoSuchElementException(ex.getMessage());
+                        } catch (SOAPExceptionImpl ex) {
+                            HBox errorBox = new HBox();
+                            errorBox.setAlignment(Pos.CENTER);
+                            errorBox.setPadding(new Insets(10, 10, 10, 10));
+                            errorBox.getChildren().add(new Text("Keine Verbindung zu einer Rdf oder SOAP Schnittstelle möglich!"));
+
+                            controlBox[0].getChildren().add(errorBox);
+                        }
+                    }
+
+                    if (!controlBox[0].getChildren().contains(newCalcRequestControlBox)) {
+                        controlBox[0].getChildren().add(newCalcRequestControlBox);
+                    }
+                } else {
+                    Alert alert = new Alert(Alert.AlertType.ERROR);
+                    alert.setTitle("Error");
+                    alert.setHeaderText("Invalid Date");
+                    alert.showAndWait();
+                }
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+
+        });
+
+        dp.setValue(LocalDate.now());
+
+        Platform.runLater(() -> {
+            dp.getOnAction().handle(new ActionEvent(dp, null));
+        });
+
+        VBox.setVgrow(newCalcRequestControlBox, Priority.ALWAYS);
+        newCalcRequestControlBox.setAlignment(Pos.BOTTOM_RIGHT);
+        newCalcRequestControlBox.setId("newCalcRequestControlBox");
+
+        servBox.getChildren().add(serverBtn);
+        servBox.setAlignment(Pos.TOP_RIGHT);
+
+        HBox aprioriControlBox = new HBox();
+        Region region = new Region();
+        HBox.setHgrow(region, Priority.ALWAYS);
+        aprioriControlBox.setPadding(new Insets(10, 10, 0, 10));
+        aprioriControlBox.getChildren().addAll(dp, vpBox, region, servBox);
+
+        controlBox[0].getChildren().addAll(aprioriControlBox);
+
+        return controlBox[0];
+    }
+
+    public XMLGregorianCalendar stichtagEvent(DatePicker dp) throws DatatypeConfigurationException {
+        if (dp.getValue() == null) {
+            return null;
+        }
+        int day = dp.getValue().getDayOfMonth();
+        int month = dp.getValue().getMonthValue();
+        int year = dp.getValue().getYear();
+
+        return DatatypeFactory.newInstance().newXMLGregorianCalendarDate(year, month, day, 0);
+    }
+
+    public VBox buttonAuskunft(APrioriVerkaufsproduktType verkaufsprodukt, VBox vbox, Button newCalcRequest,
+                               AtomicReference<XMLGregorianCalendar> stichtag, ToggleSwitch serverBtn) throws Exception {
+        while (vbox.getChildren().size() > 1) {
+            vbox.getChildren().removeLast();
+        }
+
+        VBox treeBox = new VBox();
+        VBox infoBox = new VBox();
+
+        TreeItem<GuiProdukt> vkp = treeHelper.aprioriItemToCalcItem(new TreeItem<>(new GuiProdukt(verkaufsprodukt)));
+        vkp.setExpanded(true);
+
+        treeHelper.aprioriProduktToTree(verkaufsprodukt, vkp);
+
+        TreeView<GuiProdukt> tv = new TreeView<>(vkp);
+        
+
+        tv.getSelectionModel().selectedItemProperty().addListener((obs, oldSelection, newSelection) -> {
+            if (newSelection != null) {
+                if (!infoBox.getChildren().isEmpty()) {
+                    infoBox.getChildren().removeAll(infoBox.getChildren());
+                }
+
+                if (isMeldungVorhanden((ProduktbausteinType) newSelection.getValue().getProdukt(), tv)){
+                    ((ProduktbausteinType) newSelection.getValue().getProdukt()).getAttribute().removeIf(a -> a.getBezeichnung().equals("Praemie"));
+                }
+                ItemAttribute itemAttribute = new ItemAttribute();
+                itemAttribute.setRisikoobjekte(risikoobjektView.getRisikoobjekte());
+                if (!infoBoxFromItem.isEmpty()) itemAttribute.setInfoBoxFromItem(infoBoxFromItem);
+
+                itemAttribute.addItemInfo(newSelection, infoBox);
+                if (newSelection.getValue().getProdukt() instanceof VerkaufsproduktType){
+                    itemAttribute.addVpInfo(infoBox, isMeldungVorhanden((ProduktbausteinType) newSelection.getValue().getProdukt(), tv), (VerkaufsproduktType) newSelection.getValue().getProdukt());
+                }
+                infoBoxFromItem = itemAttribute.getInfoBoxFromItem();
+            }else{
+                infoBox.getChildren().removeAll(infoBox.getChildren());
+            }
+        });
+
+        final TreeItem<GuiProdukt> originalRoot = treeHelper.cloneTreeItem(tv.getRoot());
+        tv.setCellFactory(tc -> new TreeCell<>() {
+            @Override
+            public void updateItem(GuiProdukt item, boolean empty) {
+                super.updateItem(item, empty);
+
+                if (item == null || empty) {
+                    setText(null);
+                    setGraphic(null);
+                    setStyle("");
+                } else {
+                    HBox cellBox = new HBox();
+                    Button include = new Button("+");
+                    include.setStyle("-fx-margin: 5;");
+                    Label label = new Label(((ProduktbausteinType) item.getProdukt()).getBezeichnung() + " ");
+                    Button remove = new Button("-");
+
+                    remove.setVisible(true);
+                    remove.setFont(Font.font("System", FontWeight.BOLD, include.getFont().getSize() + 2));
+                    remove.setPadding(new Insets(0, 5, 0, 5));
+
+                    include.setFont(Font.font("System", FontWeight.BOLD, include.getFont().getSize() + 2));
+                    include.setPadding(new Insets(0, 5, 0, 5));
+
+                    if (!shouldBeIncluded(getTreeItem())) {
+                        label.setFont(Font.font("System", FontPosture.ITALIC, label.getFont().getSize()));
+                        label.setTextFill(Paint.valueOf("#A0A0A0"));
+                        if (!(getTreeItem().getValue().isNotIncluded())) {
+                            getTreeItem().getValue().setNotIncluded(true);
+                        }
+                        remove.setDisable(true);
+                        remove.setStyle("-fx-background-color: #CCCCCC");
+                    } else {
+                        label.setTextFill(Paint.valueOf("#000000"));
+                        remove.setVisible(true);
+
+                        getTreeItem().getValue().setNotIncluded(false);
+                    }
+
+                    Region spacer = new Region();
+                    HBox.setHgrow(spacer, Priority.ALWAYS);
+                    Label spacer2 = new Label(" ");
+
+                    label.setMaxWidth(Double.MAX_VALUE);
+
+                    if (getTreeItem().getValue().getProdukt() instanceof VerkaufsproduktType ||
+                            getTreeItem().getValue().getClass().equals(APrioriVerkaufsproduktType.class)) {
+                        cellBox.getChildren().addAll(label);
+                    } else if (timesItemisIncludedById.get(
+                            ((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getId()) != null
+                            &&  ((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getMaxVorkommen() != null
+                            && ((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getMaxVorkommen() <=
+                            timeItemIsIncludedByParent(getTreeItem().getParent(),
+                                    ((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getId())) {
+                        include.setDisable(true);
+                        include.setStyle("-fx-background-color: #CCCCCC");
+                        cellBox.getChildren().addAll(label, spacer, include, spacer2, remove);
+                    } else {
+                        cellBox.getChildren().addAll(label, spacer, include, spacer2, remove);
+                    }
+
+                    include.setOnAction(e -> {
+                        if (getTreeItem().getValue().isNotIncluded()) {
+                            label.setFont(Font.font("System", label.getFont().getSize()));
+                            label.setTextFill(Paint.valueOf("#000000"));
+                            remove.setVisible(true);
+
+                            timesItemisIncludedById.put(((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getId(),
+                                    (timesItemisIncludedById.get(
+                                            ((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getId()) != null ?
+                                            timesItemisIncludedById.get(
+                                                    ((ProduktbausteinType) getTreeItem().getValue().getProdukt()).getId()) + 1 : 1));
+
+                            getTreeItem().getValue().setNotIncluded(false);
+                            includeAddedParent(getTreeItem());
+                            includeAddedChildren(getTreeItem());
+                            tv.setRoot(treeHelper.sortTree(tv.getRoot()));
+                            tv.refresh();
+                            timesItemisIncludedById.clear();
+                            refreshTimesItemisIncludedById(tv.getRoot());
+                        } else {
+                            TreeItem<GuiProdukt> parent = getTreeItem().getParent();
+                            TreeItem<GuiProdukt> clone = null;
+                            try {
+                                clone = treeHelper.cloneTreeItem(
+                                        treeHelper.findTreeItem((ProduktbausteinType) item.getProdukt(), tv.getRoot()));
+                            } catch (Exception ex) {
+                                throw new RuntimeException(ex);
+                            }
+                            parent.getChildren().add(clone);
+
+                            timesItemisIncludedById.clear();
+                            refreshTimesItemisIncludedById(tv.getRoot());
+
+                            tv.setRoot(treeHelper.sortTree(tv.getRoot()));
+                            tv.refresh();
+                        }
+
+                        TreeItem<GuiProdukt> newRoot = checkPlausis(plausiList, tv.getRoot(), verkaufsprodukt);
+                        if (newRoot != null) {
+                            newRoot.setExpanded(true);
+                            tv.setRoot(newRoot);
+                            tv.refresh();
+                        }
+                    });
+
+                    remove.setOnAction(e -> {
+                        Map<String, Integer> countByParent = new HashMap<>();
+                        Map<String, Integer> countByAprioriParent = new HashMap<>();
+                        timesItemisIncludedById.clear();
+                        refreshTimesItemisIncludedById(tv.getRoot());
+                        timesItemisIncludedById.replace(((ProduktbausteinType) item.getProdukt()).getId(),
+                                timesItemisIncludedById.get(((ProduktbausteinType) item.getProdukt()).getId()) - 1);
+
+                        if (countChildIds(countByParent, getTreeItem().getParent()).get
+                                (((ProduktbausteinType) item.getProdukt()).getId()).equals(countChildIds(countByAprioriParent,
+                                treeHelper.findTreeItem(((ProduktbausteinType) item.getProdukt()), originalRoot).getParent()).get(
+                                        ((ProduktbausteinType) item.getProdukt()).getId()))) {
+                            label.setFont(Font.font("System", label.getFont().getSize()));
+                            label.setTextFill(Paint.valueOf("#A0A0A0"));
+                            remove.setVisible(false);
+
+                            getTreeItem().getValue().setNotIncluded(true);
+                            includeAddedChildren(getTreeItem());
+
+                            tv.setRoot(treeHelper.sortTree(tv.getRoot()));
+                            tv.refresh();
+                        } else {
+                            getTreeItem().getParent().getChildren().remove((getTreeItem()));
+                        }
+
+                        TreeItem<GuiProdukt> newRoot = checkPlausis(plausiList, tv.getRoot(), verkaufsprodukt);
+                        if (newRoot != null) {
+                            newRoot.setExpanded(true);
+
+                            tv.setRoot(newRoot);
+                            tv.refresh();
+                        }
+
+                        timesItemisIncludedById.clear();
+                        refreshTimesItemisIncludedById(tv.getRoot());
+                    });
+
+                    if(((ProduktbausteinType) item.getProdukt()).getMeldungen() != null && !((ProduktbausteinType) item.getProdukt()).getMeldungen().isEmpty()) {
+                        AtomicBoolean symboleAdded = new AtomicBoolean(false);
+                        Text symbole = new Text("\u26A0 ");
+                        symbole.setFont(Font.font("System", FontWeight.BOLD, symbole.getFont().getSize() + 2));
+
+
+                        ((ProduktbausteinType) item.getProdukt()).getMeldungen().forEach(m -> {
+                            if(m.getErrorType().equals(BigInteger.ONE)) {
+                                symbole.setFill(Paint.valueOf("#aa3333"));
+                                symboleAdded.set(true);
+                            }
+                            if (m.getErrorType().equals(BigInteger.TWO) && !symboleAdded.get()) {
+                                symbole.setFill(Paint.valueOf("#ccbb00"));
+                            }
+                        });
+                        cellBox.getChildren().addFirst(symbole);
+                    }else {
+                        if (cellBox.getChildren().getFirst() instanceof Text && ((Text)cellBox.getChildren().getFirst()).getText().equals("\u26A0")) {
+                            cellBox.getChildren().removeFirst();
+                        }
+                    }
+                    setGraphic(cellBox);
+                    setText(null);
+                }
+            }
+        });
+
+        newCalcRequest.setOnAction(e -> {
+            try {
+                TreeItem<GuiProdukt> cleanedRoot = treeHelper.cleanTree(tv.getRoot());
+
+
+                CalculateRequestAuskunftService s = new CalculateRequestAuskunftService(new SOAPConnector());
+                TreeItem<GuiProdukt> newRoot = new TreeItem<>(cleanedRoot.getValue());
+                treeHelper.setTimesItemisIncludedById(timesItemisIncludedById);
+                if (serverBtn.isSelected()) {
+                    VerkaufsproduktType calcResponse = s.calculateRDFAuskunft(new TreeView<>(cleanedRoot), stichtag.get());
+                    newRoot.getValue().setProdukt(calcResponse);
+                    treeHelper.produktToTree(calcResponse, newRoot);
+                }else {
+                    CalculateResponse calcResponse = s.calculateAuskunft(new TreeView<>(cleanedRoot), stichtag.get());
+                    newRoot.getValue().setProdukt(calcResponse.getBerechnungsantwort().getVerkaufsprodukt());
+                    treeHelper.produktToTree(calcResponse.getBerechnungsantwort().getVerkaufsprodukt(), newRoot);
+                }
+
+                timesItemisIncludedById = treeHelper.getTimesItemisIncludedById();
+                newRoot.setExpanded(true);
+
+                TreeItem<GuiProdukt> finalRoot = checkPlausis(plausiList, newRoot, verkaufsprodukt);
+                if (finalRoot != null) {
+                    finalRoot.setExpanded(true);
+                    tv.setRoot(finalRoot);
+                } else {
+                    newRoot = treeHelper.addAprioriToCalc(newRoot, originalRoot);
+                    newRoot = treeHelper.sortTree(newRoot);
+                    tv.setRoot(newRoot);
+                }
+
+
+
+                timesItemisIncludedById.clear();
+
+                refreshTimesItemisIncludedById(tv.getRoot());
+
+                tv.refresh();
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+        });
+
+        if (!treeBox.getChildren().isEmpty()) {
+            treeBox.getChildren().clear();
+        }
+
+        tv.setRoot(treeHelper.sortTree(tv.getRoot()));
+
+        VBox.setVgrow(tv, Priority.ALWAYS);
+        tv.setMaxSize(Double.MAX_VALUE, Double.MAX_VALUE);
+        tv.setStyle("-fx-border-color: white;");
+
+        treeBox.getChildren().add(tv);
+        treeBox.setPadding(new Insets(10));
+        treeBox.setMaxSize(Double.MAX_VALUE, Double.MAX_VALUE);
+        HBox.setHgrow(treeBox, Priority.ALWAYS);
+        treeBox.setStyle("-fx-border-color: black; -fx-background-color: white");
+
+        infoBox.setStyle("-fx-border-color: black; -fx-background-color: white");
+        infoBox.setMaxSize(Double.MAX_VALUE, Double.MAX_VALUE);
+        HBox.setHgrow(infoBox, Priority.ALWAYS);
+
+        HBox splitBox = new HBox(treeBox, infoBox);
+        splitBox.setId("splitBox");
+        splitBox.setSpacing(10);
+        splitBox.setPadding(new Insets(20));
+        splitBox.setMaxSize(Double.MAX_VALUE, Double.MAX_VALUE);
+
+        VBox wrapper = new VBox(splitBox);
+        wrapper.setAlignment(Pos.CENTER);
+        VBox.setVgrow(splitBox, Priority.ALWAYS);
+
+        HBox logWrapper = new HBox();
+        logWrapper.setPadding(new Insets(0, 20, 20, 20)); // Abstand zum Rand unten + Seite
+        logWrapper.setAlignment(Pos.CENTER_LEFT);
+        logWrapper.setMaxWidth(Double.MAX_VALUE);
+
+        vbox.getChildren().addAll(wrapper);
+        VBox.setVgrow(wrapper, Priority.ALWAYS);
+
+        return vbox;
+    }
+
+    private void includeAddedParent(TreeItem<GuiProdukt> treeItem) {
+        if (treeItem.getParent() != null) {
+            treeItem.getParent().getValue().setNotIncluded(false);
+            if (treeItem.getParent().getParent() != null) {
+                includeAddedParent(treeItem.getParent());
+            }
+        }
+    }
+
+    private void includeAddedChildren(TreeItem<GuiProdukt> parent) {
+        for (int i = 0; i < parent.getChildren().size(); i++) {
+            parent.getChildren().get(i).getValue().setNotIncluded(false);
+            if (!shouldBeIncluded(parent.getChildren().get(i)) && !(parent.getChildren().get(i).getValue().isNotIncluded())) {
+                parent.getChildren().get(i).getValue().setNotIncluded(true);
+            } else {
+                parent.getChildren().get(i).getValue().setNotIncluded(false);
+            }
+
+            if (!parent.getChildren().get(i).getChildren().isEmpty() && parent.getChildren().get(i).getChildren() != null) {
+                includeAddedChildren(parent.getChildren().get(i));
+            }
+        }
+    }
+
+    public boolean shouldBeIncluded(TreeItem<GuiProdukt> treeItem) {
+        return !(((treeItem.getParent() != null && treeItem.getParent().getValue().isNotIncluded()) || treeItem.getValue().isNotIncluded() ||
+                (((ProduktbausteinType) treeItem.getValue().getProdukt()).getMinVorkommen() != null && ((ProduktbausteinType) treeItem.getValue().getProdukt()).getMinVorkommen() == 0 &&
+                        (timesItemisIncludedById.get(((ProduktbausteinType) treeItem.getValue().getProdukt()).getId()) == null ||
+                                timesItemisIncludedById.get(((ProduktbausteinType) treeItem.getValue().getProdukt()).getId()) == 0))) &&
+                !(treeItem.getValue().getProdukt() instanceof VerkaufsproduktType));
+    }
+
+    private Map<String, Integer> countChildIds(Map<String, Integer> count, TreeItem<GuiProdukt> root) {
+        if (root != null) {
+            for (int i = 0; i < root.getChildren().size(); i++) {
+                TreeItem<GuiProdukt> item = root.getChildren().get(i);
+
+                if (count.get(((ProduktbausteinType) item.getValue().getProdukt()).getId()) == null) {
+                    count.put(((ProduktbausteinType) item.getValue().getProdukt()).getId(), 1);
+                } else {
+                    count.replace(((ProduktbausteinType) item.getValue().getProdukt()).getId(),
+                            count.get(((ProduktbausteinType) item.getValue().getProdukt()).getId()) + 1);
+                }
+
+                if (!item.getChildren().isEmpty()) {
+                    countChildIds(count, item);
+                }
+            }
+        }
+        return count;
+
+    }
+
+    private void refreshTimesItemisIncludedById(TreeItem<GuiProdukt> root) {
+        for (int i = 0; i < root.getChildren().size(); i++) {
+            TreeItem<GuiProdukt> item = root.getChildren().get(i);
+            if (!item.getValue().isNotIncluded()) {
+                if (timesItemisIncludedById.get(((ProduktbausteinType) item.getValue().getProdukt()).getId()) == null) {
+                    timesItemisIncludedById.put(((ProduktbausteinType) item.getValue().getProdukt()).getId(), 1);
+                } else {
+                    timesItemisIncludedById.replace(((ProduktbausteinType) item.getValue().getProdukt()).getId(),
+                            timesItemisIncludedById.get(((ProduktbausteinType) item.getValue().getProdukt()).getId()) + 1);
+                }
+            }
+            if (!item.getChildren().isEmpty()) {
+                refreshTimesItemisIncludedById(item);
+            }
+        }
+    }
+
+    public int timeItemIsIncludedByParent(TreeItem<GuiProdukt> parent, String itemId) {
+        int erg = 0;
+        for (int i = 0; i < parent.getChildren().size(); i++) {
+            TreeItem<GuiProdukt> item = parent.getChildren().get(i);
+            if (((ProduktbausteinType) item.getValue().getProdukt()).getId().equals(itemId)) {
+                if (!item.getValue().isNotIncluded()) {
+                    erg++;
+                }
+            }
+
+        }
+
+        return erg;
+    }
+    public boolean isMeldungVorhanden(ProduktbausteinType produkt, TreeView<GuiProdukt> tv) {
+        TreeHelper treeHelper = new TreeHelper();
+        TreeItem<GuiProdukt> actual = treeHelper.findTreeItem(produkt, tv.getRoot());
+
+        if (actual != null && ((ProduktbausteinType)actual.getValue().getProdukt()).getMeldungen() != null && !((ProduktbausteinType)actual.getValue().getProdukt()).getMeldungen().isEmpty()) {
+            return true;
+        }
+        for (ProduktbausteinType child : produkt.getBausteine()){
+            if(isMeldungVorhanden(child, tv)) return true;
+        }
+        return false;
+    }
+
+    public TreeItem<GuiProdukt> checkPlausis(List<Plausi> plausiList, TreeItem<GuiProdukt> vp, APrioriProduktbausteinType verkaufsprodukt){
+        Repository repo = new SailRepository(new MemoryStore());
+        repo.init();
+
+        try (RepositoryConnection conn = repo.getConnection()) {
+            Model model = rdfHelper.createRdfModel(vp);
+
+            conn.add(model);
+
+            plausiList.stream().filter(p -> p.getArt().equals("update")).forEach(p -> {
+                String query = p.getQuery();
+
+                conn.prepareUpdate(query).execute();
+            });
+
+            model.clear();
+            conn.getStatements(null, null, null).forEach(model::add);
+
+            plausiList.stream().filter(p -> p.getArt().equals("graph")).forEach(p -> {
+                String sparql = p.getQuery();
+
+                GraphQuery q = conn.prepareGraphQuery(sparql);
+                Model validatedModel = QueryResults.asModel(q.evaluate());
+
+                model.addAll(validatedModel);
+            });
+
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            Rio.write(model, baos, RDFFormat.JSONLD);
+
+            VerkaufsproduktType neuRoot = rdfHelper.calculateRequestToVerkaufsprodukt(baos.toString());
+            TreeItem<GuiProdukt> newRoot = new TreeItem<>(new GuiProdukt(neuRoot));
+            newRoot.setExpanded(true);
+
+            try {
+                treeHelper.produktToTree(neuRoot, newRoot);
+
+                TreeItem<GuiProdukt> aprioriTree = new TreeItem<>();
+                treeHelper.aprioriProduktToTree(verkaufsprodukt, aprioriTree);
+
+                return (treeHelper.sortTree(treeHelper.addAprioriToCalc(newRoot, aprioriTree)));
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+        } catch(Exception ignored) {
+            ignored.printStackTrace();
+            System.out.println("CheckPlausi: " + ignored.getMessage());
+            return null;
+        }
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/RisikoobjektView.java

@@ -0,0 +1,219 @@
+package at.vvo.omds.client.gui;
+
+import at.vvo.omds.types.omds3.r2025_05.common.FahrzeugType;
+import at.vvo.omds.types.omds3.r2025_05.common.VersichertesInteresseMitAttributMetadatenType;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.*;
+import javafx.scene.layout.*;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontWeight;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class RisikoobjektView {
+    List<VersichertesInteresseMitAttributMetadatenType> risikoobjekte = new ArrayList<>();
+    VBox objekteListe = new VBox();
+    ScrollPane objekteScroll = new ScrollPane();
+    GridPane main = new GridPane();
+
+    public List<VersichertesInteresseMitAttributMetadatenType> getRisikoobjekte() {
+        return risikoobjekte;
+    }
+
+    public GridPane risikoobjekte() {
+        VBox createObjekt = createRisikoobjekt();
+
+        objekteListe = risikoobjekteListe();
+
+        objekteScroll.setContent(objekteListe);
+        objekteScroll.setFitToWidth(true);
+        objekteScroll.setFitToHeight(false);
+        objekteScroll.setStyle("-fx-background-color:transparent;");
+
+        main.add(createObjekt, 0, 0);
+        main.add(objekteScroll, 1, 0);
+
+        GridPane.setHgrow(createObjekt, Priority.ALWAYS);
+        GridPane.setVgrow(createObjekt, Priority.ALWAYS);
+        GridPane.setHgrow(objekteScroll, Priority.ALWAYS);
+        GridPane.setVgrow(objekteScroll, Priority.ALWAYS);
+
+        createObjekt.setPadding(new Insets(10, 10, 10, 5));
+        createObjekt.setStyle("-fx-border-color: black; -fx-border-width: 1px;");
+
+        objekteScroll.setPadding(new Insets(10, 10, 10, 5));
+        objekteScroll.setStyle("-fx-border-color: black; -fx-border-width: 1px;");
+
+        main.setAlignment(Pos.CENTER);
+        main.setPadding(new Insets(10));
+        main.setHgap(10);
+
+        return main;
+    }
+
+    private VBox risikoobjekteListe() {
+        VBox objekteListe = new VBox(10); // spacing
+        objekteListe.setFillWidth(true);
+
+        if (risikoobjekte != null && !risikoobjekte.isEmpty()) {
+            for (VersichertesInteresseMitAttributMetadatenType r : risikoobjekte) {
+
+
+                HBox singleRisikoobjekt = new HBox(10);
+                singleRisikoobjekt.setPadding(new Insets(5));
+                singleRisikoobjekt.setAlignment(Pos.CENTER);
+
+                VBox objektInfo = new VBox(2);
+
+                if (r instanceof FahrzeugType fahrzeug) {
+                    Label handelsbezeichnung = new Label(fahrzeug.getHandelsbez());
+                    handelsbezeichnung.setFont(Font.font("System", FontWeight.BOLD, 14));
+
+                    Label baujahr = new Label(fahrzeug.getBaujahr().toString());
+                    baujahr.setStyle("-fx-text-fill: #555555");
+
+                    Label erstzulassung = new Label(fahrzeug.getErstzulassdat().toString()
+                            .substring(0, fahrzeug.getErstzulassdat().toString().length()-1));
+                    erstzulassung.setStyle("-fx-text-fill: #555555");
+
+                    objektInfo.getChildren().addAll(handelsbezeichnung, baujahr, erstzulassung);
+
+                    Pane separator = new Pane();
+                    separator.setPrefWidth(2);
+                    separator.setMaxWidth(2);
+                    separator.setStyle("-fx-background-color: black;");
+
+                    Label symbole = new Label("\u26DF");
+                    symbole.setFont(Font.font(18));
+
+                    VBox symbolBox = new VBox(symbole);
+
+                    singleRisikoobjekt.getChildren().addAll(symbolBox, separator, objektInfo);
+                    singleRisikoobjekt.setAlignment(Pos.CENTER_LEFT);
+                }
+
+                objekteListe.getChildren().add(singleRisikoobjekt);
+            }
+        }
+        return objekteListe;
+    }
+
+    private VBox createRisikoobjekt() {
+        VBox createForm = new VBox();
+        ChoiceBox<String> choiceBox = new ChoiceBox<>();
+
+        List<String> risikoobjektArten = new ArrayList<>();
+        risikoobjektArten.add("Versichertes objekt SachPrivat");
+        risikoobjektArten.add("Versicherte Liegenschaft");
+        risikoobjektArten.add("Fahrzeug");
+        risikoobjektArten.add("Risiko Gebaeude");
+        risikoobjektArten.add("Versicherte Person");
+        risikoobjektArten.add("Risiko Haushalt");
+
+        choiceBox.getSelectionModel().selectedItemProperty().addListener((obs, oldVal, newVal) -> {
+            if (newVal != null) {
+                int a = createForm.getChildren().size();
+                for (int i = 1; i < a; i++) {
+                    createForm.getChildren().remove(i);
+                }
+                switch (newVal) {
+                    case "Versichertes objekt SachPrivat": {
+                        System.out.println("formular sach Privat");
+                        break;
+                    }
+                    case "Versicherte Liegenschaft": {
+                        System.out.println("create Versicherte Liegenschaft");
+                        break;
+                    }
+                    case "Fahrzeug": {
+                        FahrzeugType fahrzeug = new FahrzeugType();
+
+                        VBox createFormBox = new VBox();
+
+                        VBox baujahrBox = new VBox();
+                        Label label1 = new Label("Baujahr");
+                        TextField textField1 = new TextField();
+
+                        textField1.setPromptText("Baujahr");
+                        baujahrBox.setPadding(new Insets(5));
+                        baujahrBox.getChildren().addAll(label1, textField1);
+
+                        textField1.focusedProperty().addListener((observableValue, oldValue, newValue) -> {
+                            if (!newValue) {
+                                Label failedCheck = new Label("Es muss eine 4 stellige Jahreszahl mitgegeben werden");
+                                failedCheck.setId("failedCheck");
+                                failedCheck.setTextFill(Paint.valueOf("#DD0000"));
+                                if (textField1.getText().length() != 4) {
+                                    textField1.setStyle("-fx-border-color: #dd0000");
+                                    baujahrBox.getChildren().addAll(failedCheck);
+                                } else {
+                                    textField1.setStyle("-fx-border-color: #555555");
+                                    baujahrBox.getChildren().removeIf(c -> c.getId() != null && c.getId().equals("failedCheck"));
+                                }
+                            }
+                        });
+
+                        VBox handelsbezeichnungBox = new VBox();
+                        Label label2 = new Label("Handelsbezeichnung");
+                        TextField textField2 = new TextField();
+
+                        textField2.setPromptText("Handelsbezeichnung");
+                        handelsbezeichnungBox.setPadding(new Insets(5));
+                        handelsbezeichnungBox.getChildren().addAll(label2, textField2);
+
+                        VBox erstzulassungBox = new VBox();
+                        Label label3 = new Label("Erstzulassung");
+                        DatePicker datePicker = new DatePicker(LocalDate.now());
+
+                        erstzulassungBox.setPadding(new Insets(5));
+                        erstzulassungBox.getChildren().addAll(label3, datePicker);
+
+                        Button createBtn = new Button("Create");
+
+                        createBtn.setOnAction(e -> {
+                            fahrzeug.setBaujahr(Integer.valueOf(textField1.getText()));
+                            fahrzeug.setHandelsbez(textField2.getText());
+                            try {
+                                int day = datePicker.getValue().getDayOfMonth();
+                                int month = datePicker.getValue().getMonthValue();
+                                int year = datePicker.getValue().getYear();
+
+                                XMLGregorianCalendar erstzulassung = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(year, month, day, 0);
+
+                                fahrzeug.setErstzulassdat(erstzulassung);
+                            } catch (DatatypeConfigurationException ex) {
+                                throw new RuntimeException(ex);
+                            }
+
+                            risikoobjekte.add(fahrzeug);
+
+                            objekteListe.getChildren().setAll(risikoobjekteListe().getChildren());
+
+                            createFormBox.getChildren().clear();
+                            String select = choiceBox.getSelectionModel().getSelectedItem();
+                            choiceBox.getSelectionModel().clearSelection();
+                            choiceBox.getSelectionModel().select(select);
+
+                        });
+
+                        createFormBox.getChildren().addAll(baujahrBox, handelsbezeichnungBox, erstzulassungBox, createBtn);
+                        createForm.getChildren().add(createFormBox);
+                        break;
+                    }
+                }
+            }
+        });
+
+        choiceBox.getItems().addAll(risikoobjektArten);
+
+        createForm.getChildren().addAll(choiceBox);
+        return createForm;
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/api/SOAPConnector.java

@@ -0,0 +1,215 @@
+package at.vvo.omds.client.gui.api;
+
+import at.vvo.omds.types.omds3.r2025_05.common.ProductsRequest;
+import at.vvo.omds.types.omds3.r2025_05.common.ProductsResponse;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.common.CalculateRequest;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.common.CalculateResponse;
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBElement;
+import jakarta.xml.bind.Marshaller;
+import jakarta.xml.bind.Unmarshaller;
+import jakarta.xml.soap.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.FileReader;
+
+public class SOAPConnector {
+
+    static Logger logger = LoggerFactory.getLogger(SOAPConnector.class);
+
+    public CalculateResponse calculateRequestAuskunft(String url, JAXBElement<CalculateRequest> request, String token) throws Exception {
+
+        logger.info("Url:" + url);
+        logger.info("Request VUNr:" + request.getValue().getVUNr());
+
+        SOAPConnectionFactory connectionFactory = SOAPConnectionFactory.newInstance();
+        SOAPConnection soapConnection = connectionFactory.createConnection();
+
+        SOAPMessage req = createCalcRequest(request, token);
+
+        SOAPMessage response = soapConnection.call(req, url);
+
+        JAXBContext jaxbContext = JAXBContext.newInstance(at.vvo.omds.types.omds3.r2025_05.on2antrag.common.ObjectFactory.class);
+        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();;
+
+        System.out.println("-----------------------------------------------------------------------------");
+        printMessage(response);
+        System.out.println("-----------------------------------------------------------------------------");
+        printMessage(req);
+
+        CalculateResponse erg =
+                (CalculateResponse) unmarshaller.unmarshal(response.getSOAPBody().extractContentAsDocument());
+        soapConnection.close();
+
+        return erg;
+    }
+
+    public ProductsResponse aprioriAuskunft(String url, JAXBElement<ProductsRequest> request, String token) throws Exception {
+
+        logger.info("Url:" + url);
+        logger.info("Request VUNr:" + request.getValue().getVUNr());
+
+        SOAPConnectionFactory connectionFactory = SOAPConnectionFactory.newInstance();
+        SOAPConnection soapConnection = connectionFactory.createConnection();
+
+        SOAPMessage req = createRequest(request, token);
+
+        SOAPMessage response = soapConnection.call(req, url);
+
+        JAXBContext jaxbContext = JAXBContext.newInstance(at.vvo.omds.types.omds3.r2025_05.common.ObjectFactory.class, at.vvo.omds.types.omds2.v2_17.ObjectFactory.class, at.vvo.omds.types.omds3.r2025_05.on2antrag.common.ObjectFactory.class);
+        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
+
+        ProductsResponse erg =
+                (ProductsResponse) unmarshaller.unmarshal(response.getSOAPBody().extractContentAsDocument());
+        soapConnection.close();
+
+       return erg;
+    }
+
+    private SOAPMessage createCalcRequest(JAXBElement<CalculateRequest> request, String token) throws Exception {
+        MessageFactory messageFactory = MessageFactory.newInstance(SOAPConstants.SOAP_1_2_PROTOCOL);
+        SOAPMessage soapMessage = messageFactory.createMessage();
+
+        createCalcEnvelope(soapMessage, request, token);
+
+        MimeHeaders mimeHeaders = soapMessage.getMimeHeaders();
+        mimeHeaders.addHeader("Content-Type", "application/soap+xml");
+
+        soapMessage.saveChanges();
+
+        return soapMessage;
+    }
+
+    private SOAPMessage createRequest(JAXBElement<ProductsRequest> request, String token) throws Exception {
+        MessageFactory messageFactory = MessageFactory.newInstance(SOAPConstants.SOAP_1_2_PROTOCOL);
+        SOAPMessage soapMessage = messageFactory.createMessage();
+
+        createEnvelope(soapMessage, request, token);
+
+        MimeHeaders mimeHeaders = soapMessage.getMimeHeaders();
+        mimeHeaders.addHeader("Content-Type", "application/soap+xml");
+
+        soapMessage.saveChanges();
+
+        return soapMessage;
+    }
+
+    private void createEnvelope(SOAPMessage soapMessage, JAXBElement<ProductsRequest> request, String token) throws Exception {
+        SOAPPart soapPart = soapMessage.getSOAPPart();
+
+        SOAPEnvelope envelope = soapPart.getEnvelope();
+        SOAPHeader soapHeader = envelope.getHeader();
+
+        Name headerElementName = envelope.createName(
+                "Security",
+                "wsse",
+                "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+        );
+        SOAPHeaderElement soapHeaderElement = soapHeader.addHeaderElement(headerElementName);
+
+        SOAPElement securityContextTokenSOAPElement = soapHeaderElement.addChildElement("SecurityContextToken", "wsc", "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512");
+        securityContextTokenSOAPElement.addNamespaceDeclaration("wsu", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
+        securityContextTokenSOAPElement.addAttribute(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd", "Id", "wsu"), "authPolicy");
+        SOAPElement identifierSOAPElement = securityContextTokenSOAPElement.addChildElement("Identifier", "wsc");
+//        identifierSOAPElement.addTextNode(getToken(request.getValue().getVUNr()));
+        identifierSOAPElement.addTextNode("eintollertoken");
+        JAXBContext jaxbContext = JAXBContext.newInstance("at.vvo.omds.types.omds3.r2025_05.common");
+
+        SOAPBody body = envelope.getBody();
+
+        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+        Marshaller marshaller = jaxbContext.createMarshaller();
+
+        marshaller.marshal(request,document);
+
+        body.addDocument(document);
+
+        soapMessage.saveChanges();
+
+    }
+
+    private void createCalcEnvelope(SOAPMessage soapMessage, JAXBElement<CalculateRequest> request, String token) throws Exception {
+        SOAPPart soapPart = soapMessage.getSOAPPart();
+
+        SOAPEnvelope envelope = soapPart.getEnvelope();
+        SOAPHeader soapHeader = envelope.getHeader();
+
+        Name headerElementName = envelope.createName(
+                "Security",
+                "wsse",
+                "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+        );
+        SOAPHeaderElement soapHeaderElement = soapHeader.addHeaderElement(headerElementName);
+
+        SOAPElement securityContextTokenSOAPElement = soapHeaderElement.addChildElement("SecurityContextToken", "wsc", "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512");
+        securityContextTokenSOAPElement.addNamespaceDeclaration("wsu", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
+        securityContextTokenSOAPElement.addAttribute(new QName("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd", "Id", "wsu"), "authPolicy");
+        SOAPElement identifierSOAPElement = securityContextTokenSOAPElement.addChildElement("Identifier", "wsc");
+//        identifierSOAPElement.addTextNode(getToken(request.getValue().getVUNr()));
+        identifierSOAPElement.addTextNode("eintollertoken");
+        JAXBContext jaxbContext = JAXBContext.newInstance(at.vvo.omds.types.omds3.r2025_05.on2antrag.common.ObjectFactory.class);
+
+        SOAPBody body = envelope.getBody();
+
+        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+        Marshaller marshaller = jaxbContext.createMarshaller();
+
+        marshaller.marshal(request,document);
+
+        body.addDocument(document);
+
+        soapMessage.saveChanges();
+
+    }
+
+
+    public static void printMessage(SOAPMessage soapMessage) throws Exception {
+        TransformerFactory tff = TransformerFactory.newInstance();
+        Transformer tf = tff.newTransformer();
+
+        tf.setOutputProperty(OutputKeys.INDENT, "yes");
+        tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+
+        Source sc = soapMessage.getSOAPPart().getContent();
+
+        ByteArrayOutputStream streamOut = new ByteArrayOutputStream();
+        StreamResult result = new StreamResult(streamOut);
+        tf.transform(sc, result);
+
+        String strMessage = streamOut.toString();
+
+        logger.atInfo().log("----- SOAPMessage -----");
+        logger.atInfo().log(strMessage);
+    }
+
+    public String getToken(String vunr) throws Exception {
+        BufferedReader br = new BufferedReader(
+                new FileReader(System.getProperty("user.home") + "\\OMDSSchlüssel.txt"));
+
+        String[] tokens = br.lines().toArray(String[]::new);
+        if (tokens.length > 1) {
+            for (String token : tokens) {
+                if (token.contains(vunr)) {
+                    if (!(token.replaceAll(".*[=: ]\\s*", "").contains(vunr))){
+                        return token.replaceAll(".*[=: ]\\s*","");
+                    }
+                    throw new Exception("Der Token mit der angegebenen VuNr hat ein ungültiges Format");
+                }
+            }
+            throw new Exception("Kein Token für die angegebene VuNr vorhanden");
+        }else{
+            throw new Exception("Keine Tokens in der Datei");
+        }
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/api/apriori/AprioriAuskunftService.java

@@ -0,0 +1,54 @@
+package at.vvo.omds.client.gui.api.apriori;
+
+import at.vvo.omds.helpers.Plausi;
+import at.vvo.omds.helpers.RDFHelper;
+import at.vvo.omds.client.gui.api.SOAPConnector;
+import at.vvo.omds.types.omds3.r2025_05.common.APrioriVerkaufsproduktType;
+import at.vvo.omds.types.omds3.r2025_05.common.ProductsRequest;
+import at.vvo.omds.types.omds3.r2025_05.common.ProductsResponse;
+import jakarta.xml.bind.JAXBElement;
+import javafx.util.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.util.List;
+
+
+public class AprioriAuskunftService {
+
+    Logger log = LoggerFactory.getLogger(AprioriAuskunftService.class);
+
+    private final SOAPConnector soapConnector;
+
+    public AprioriAuskunftService(SOAPConnector soapConnector) {
+        this.soapConnector = soapConnector;
+    }
+
+    public ProductsResponse aprioriAuskunft(XMLGregorianCalendar stichtag, String vuNr) throws Exception {
+
+        String token = "<KEY>";
+        JAXBElement<ProductsRequest> r = BuildProductsRequest.aprioriRequest(stichtag, vuNr);
+
+        ProductsResponse response =
+                soapConnector.aprioriAuskunft(
+                        "http://localhost:9090/ws", r, token
+                );
+        log.info("Got Response As below ========= : ");
+        log.info("Status : {}", response.getVerkaufsprodukt().getFirst().getName());
+
+        return response;
+    }
+
+    public Pair<List<APrioriVerkaufsproduktType>, List<Plausi>> aprioriRDFAuskunft(XMLGregorianCalendar stichtag, String vuNr) throws Exception {
+        JAXBElement<ProductsRequest> r = BuildProductsRequest.aprioriRequest(stichtag, vuNr);
+
+        RDFHelper rdfHelper = new RDFHelper();
+        Pair<List<APrioriVerkaufsproduktType>, List<Plausi>> response = rdfHelper.getAprioriRDF(r);
+
+        log.info("Got Response As below ========= : ");
+        log.info("Status : {}", response.getKey().getFirst().getName());
+
+        return response;
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/api/apriori/BuildProductsRequest.java

@@ -0,0 +1,38 @@
+package at.vvo.omds.client.gui.api.apriori;
+
+import at.vvo.omds.types.omds3.r2025_05.common.*;
+import jakarta.xml.bind.JAXBElement;
+import jakarta.xml.bind.annotation.XmlElementDecl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+import javax.xml.namespace.QName;
+
+public class BuildProductsRequest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BuildProductsRequest.class);
+
+    private static final ObjectFactory OUOF =
+            new ObjectFactory();
+
+    /** Privater default Constructor versteckt den nicht benötigten Default-Constructor. */
+    private BuildProductsRequest() {
+    }
+
+    static public JAXBElement<ProductsRequest> aprioriRequest(XMLGregorianCalendar Stichtag, String vuNr) {
+        LOG.info("VUNr = " + vuNr);
+
+        ProductsRequest request = OUOF.createProductsRequest();
+        request.setKorrelationsId("123456");
+        request.setVUNr(vuNr);
+        request.setStichtag(Stichtag);
+        return createProductsRequest(request);
+    }
+
+    @XmlElementDecl(namespace = "urn:omds3CommonServiceTypes-1-1-0", name = "ProductsRequest")
+    public static JAXBElement<ProductsRequest> createProductsRequest(ProductsRequest value) {
+        return new JAXBElement<>(new QName("urn:omds3CommonServiceTypes-1-1-0","ProductsRequest"),
+                ProductsRequest.class, null, value);
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/api/calc/BuildCalculateRequestAuskunft.java

@@ -0,0 +1,96 @@
+package at.vvo.omds.client.gui.api.calc;
+
+import at.vvo.omds.helpers.GuiProdukt;
+import at.vvo.omds.helpers.ObjectFactoryFactory;
+import at.vvo.omds.helpers.RDFHelper;
+import at.vvo.omds.types.omds3.r2025_05.common.*;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.common.*;
+import jakarta.xml.bind.JAXBElement;
+import javafx.scene.control.TreeItem;
+import javafx.scene.control.TreeView;
+import org.eclipse.rdf4j.model.Model;
+import org.eclipse.rdf4j.rio.RDFFormat;
+import org.eclipse.rdf4j.rio.Rio;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+import javax.xml.namespace.QName;
+import java.io.ByteArrayOutputStream;
+
+public class BuildCalculateRequestAuskunft {
+    private static final at.vvo.omds.types.omds3.r2025_05.on2antrag.common.ObjectFactory OUOF =
+            new at.vvo.omds.types.omds3.r2025_05.on2antrag.common.ObjectFactory();
+
+    private BuildCalculateRequestAuskunft(){}
+
+    static public JAXBElement<CalculateRequest> buildRequestFromTreeView(TreeView<GuiProdukt> treeView, XMLGregorianCalendar vtBeg) {
+        CalculateRequest request = OUOF.createCalculateRequest();
+        VerkaufsproduktType verkaufsprodukt = TreeViewToVerkaufsprodukt(treeView, vtBeg);
+        verkaufsprodukt.setVtgBeg(vtBeg);
+        verkaufsprodukt.setTyp(((ProduktbausteinType)treeView.getRoot().getValue().getProdukt()).getTyp());
+        SpezBerechnungGenType berechnungsanfrage = new SpezBerechnungGenType();
+
+        berechnungsanfrage.setVerkaufsprodukt(verkaufsprodukt);
+        request.setBerechnungsanfrage(berechnungsanfrage);
+        request.setKorrelationsId("12444579");
+        request.setVUNr("042");
+
+        return createCalculateRequest(request);
+    }
+
+    static public String buildRDFRequestFromTreeView(TreeView<GuiProdukt> treeView, XMLGregorianCalendar vtBeg) {
+        RDFHelper rdf = new RDFHelper();
+        Model requestModel = rdf.createRdfModel(treeView.getRoot());
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        Rio.write(requestModel, baos, RDFFormat.JSONLD);
+
+        return baos.toString();
+    }
+
+    public static JAXBElement<CalculateRequest> createCalculateRequest(CalculateRequest value) {
+        return new JAXBElement<>(new QName("urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common","CalculateRequest"),
+                CalculateRequest.class, null, value);
+    }
+
+    public static ProduktbausteinType TreeItemToBaustein(TreeItem<GuiProdukt> treeItem) {
+         ProduktbausteinType baustein = new ObjectFactoryFactory().create(
+                 ((ProduktbausteinType)treeItem.getValue().getProdukt()).getTyp());
+
+        baustein.setBezeichnung(((ProduktbausteinType)treeItem.getValue().getProdukt()).getBezeichnung());
+        baustein.setId(((ProduktbausteinType)treeItem.getValue().getProdukt()).getId());
+        baustein.setVerkaufsoffenVon(((ProduktbausteinType)treeItem.getValue().getProdukt()).getVerkaufsoffenVon());
+        baustein.setVerkaufsoffenBis(((ProduktbausteinType)treeItem.getValue().getProdukt()).getVerkaufsoffenBis());
+        baustein.getAttribute().addAll(((ProduktbausteinType)treeItem.getValue().getProdukt()).getAttribute());
+        baustein.setTyp(((ProduktbausteinType)treeItem.getValue().getProdukt()).getTyp());
+        baustein.setMinVorkommen(((ProduktbausteinType)treeItem.getValue().getProdukt()).getMinVorkommen());
+        baustein.setMaxVorkommen(((ProduktbausteinType)treeItem.getValue().getProdukt()).getMaxVorkommen());
+        baustein.getVersicherteObjekte().addAll(((ProduktbausteinType) treeItem.getValue().getProdukt()).getVersicherteObjekte());
+        baustein.setPraemienfaktor(((ProduktbausteinType)treeItem.getValue().getProdukt()).getPraemienfaktor());
+
+        return baustein;
+    }
+
+    public static VerkaufsproduktType TreeViewToVerkaufsprodukt(TreeView<GuiProdukt> treeView, XMLGregorianCalendar vtBeg) {
+        VerkaufsproduktType verkaufsprodukt = (VerkaufsproduktType) TreeItemToBaustein(treeView.getRoot());
+        verkaufsprodukt.setVtgBeg(vtBeg);
+
+        if (!treeView.getRoot().getChildren().isEmpty()) {
+            for (int i = 0; i < treeView.getRoot().getChildren().size(); i++) {
+                verkaufsprodukt.getBausteine().add((addUpFromTreeItem(treeView.getRoot().getChildren().get(i))));
+            }
+        }
+
+        return verkaufsprodukt;
+    }
+
+    public static ProduktbausteinType addUpFromTreeItem(TreeItem<GuiProdukt> treeItem) {
+        ProduktbausteinType baustein = TreeItemToBaustein(treeItem);
+
+        if (!treeItem.getChildren().isEmpty()) {
+            for (int i = 0; i < treeItem.getChildren().size(); i++) {
+                baustein.getBausteine().add(addUpFromTreeItem(treeItem.getChildren().get(i)));
+            }
+        }
+        return baustein;
+    }
+}

client-app/src/main/java/at/vvo/omds/client/gui/api/calc/CalculateRequestAuskunftService.java

@@ -0,0 +1,53 @@
+package at.vvo.omds.client.gui.api.calc;
+
+import at.vvo.omds.helpers.GuiProdukt;
+import at.vvo.omds.helpers.RDFHelper;
+import at.vvo.omds.client.gui.api.SOAPConnector;
+import at.vvo.omds.types.omds3.r2025_05.common.VerkaufsproduktType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.common.CalculateRequest;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.common.CalculateResponse;
+import jakarta.xml.bind.JAXBElement;
+import javafx.scene.control.TreeView;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+
+public class CalculateRequestAuskunftService {
+
+    Logger log = LoggerFactory.getLogger(CalculateRequestAuskunftService.class);
+
+    private final SOAPConnector soapConnector;
+
+    public CalculateRequestAuskunftService(SOAPConnector soapConnector) {
+        this.soapConnector = soapConnector;
+    }
+
+    public CalculateResponse calculateAuskunft(TreeView<GuiProdukt> treeView, XMLGregorianCalendar vtBeg) throws Exception {
+
+        String token = "<KEY>";
+        JAXBElement<CalculateRequest> r = BuildCalculateRequestAuskunft.buildRequestFromTreeView(treeView, vtBeg);
+
+        CalculateResponse response =
+                soapConnector.calculateRequestAuskunft(
+                        "http://localhost:9090/ws", r, token
+                );
+        log.info("Got Response As below ========= : ");
+        log.info("Status : {}", response.getBerechnungsantwort().getVerkaufsprodukt().getBezeichnung());
+
+        return response;
+    }
+
+    public VerkaufsproduktType calculateRDFAuskunft(TreeView<GuiProdukt> treeView, XMLGregorianCalendar vtBeg) throws Exception {
+
+        String request = BuildCalculateRequestAuskunft.buildRDFRequestFromTreeView(treeView, vtBeg);
+
+        RDFHelper rdfHelper = new RDFHelper();
+        VerkaufsproduktType response = rdfHelper.getCalculateRDF(request);
+        log.info("Got Response As below ========= : ");
+        log.info("Status : {}", response.getBezeichnung());
+
+        return response;
+    }
+}

client-app/src/main/java/com/kapdion/pisano/Main.java

@@ -1,17 +0,0 @@
-package com.kapdion.pisano;
-
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
-public class Main {
-    public static void main(String[] args) {
-        //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-        // to see how IntelliJ IDEA suggests fixing it.
-        System.out.printf("Hello and welcome!");
-
-        for (int i = 1; i <= 5; i++) {
-            //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-            // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-            System.out.println("i = " + i);
-        }
-    }
-}

client-app/src/main/resources/log4j.properties

@@ -0,0 +1,15 @@
+# Logging Properties fuer Produktion
+# Root logger
+log4j.rootLogger=INFO, stdout
+
+# Define stdout Appender
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %-12c{1}:%-3L - %m%n
+
+# Log-Level fuer Projekt
+log4j.logger.at.vvo=DEBUG
+
+# Wenn gewünscht, z.B. ändern auf Debug
+#log4j.logger.at.vvo=DEBUG

client-app/src/main/resources/logo/VVO_Logo_2024.svg

@@ -0,0 +1 @@
+<svg width="1144" height="388" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" overflow="hidden"><g transform="translate(-68 -166)"><path d="M326.308 12.6085 220.397 224.936 113.477 12.6085 12.6085 12.6085 172.989 344.465C180.554 360.603 196.693 371.195 213.336 371.195 229.979 371.195 246.118 360.603 253.683 344.465L416.081 12.6085 326.308 12.6085Z" fill="#101820" transform="matrix(1.00014 0 0 1 68 167.09)"/><path d="M778.702 12.6085 672.286 224.936 565.366 12.6085 464.498 12.6085 624.878 344.465C632.443 360.603 648.582 371.195 665.225 371.195 682.373 371.195 698.007 360.603 705.572 344.465L867.97 12.6085 778.702 12.6085 778.702 12.6085Z" fill="#101820" transform="matrix(1.00014 0 0 1 68 167.09)"/><path d="M1062.14 114.99C1018.26 114.99 993.551 149.285 993.551 191.649 993.551 234.014 1018.26 268.309 1062.14 268.309 1106.02 268.309 1131.24 234.014 1131.24 191.649 1131.24 149.285 1106.02 114.99 1062.14 114.99Z" fill="#80BC00" transform="matrix(1.00014 0 0 1 68 167.09)"/></g></svg>

client-app/src/test/java/omdsclient/ProduktauskunftTests.java

@@ -0,0 +1,45 @@
+package omdsclient;
+
+import at.vvo.omds.types.omds3.r2025_05.common.APrioriUnterbausteinType;
+import at.vvo.omds.types.omds3.r2025_05.common.APrioriProduktbausteinType;
+import at.vvo.omds.types.omds3.r2025_05.common.APrioriVerkaufsproduktType;
+
+
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.time.LocalDate;
+import javax.xml.datatype.DatatypeConfigurationException;
+import java.time.ZoneId;
+import java.util.GregorianCalendar;
+
+public class ProduktauskunftTests {
+
+
+    public void testProduktauskunft() {
+        APrioriProduktbausteinType vk_kraftfahrt_2024 = new APrioriVerkaufsproduktType();
+        vk_kraftfahrt_2024.setId("1");
+        vk_kraftfahrt_2024.setName("Kraftfahrt 2024");
+        vk_kraftfahrt_2024.setFrom(convert(LocalDate.of(2024, 1, 1)));
+
+        APrioriUnterbausteinType p_kfz_haftpflicht_2024 = new APrioriUnterbausteinType();
+        p_kfz_haftpflicht_2024.setId("2");
+        p_kfz_haftpflicht_2024.setName("Haftpflicht 2024");
+        p_kfz_haftpflicht_2024.setFrom(convert(LocalDate.of(2024, 1, 1)));
+        p_kfz_haftpflicht_2024.setTo(convert(LocalDate.of(2024, 1, 1)));
+
+    }
+
+
+    public static XMLGregorianCalendar convert(LocalDate date) {
+        try {
+            // Konvertiere LocalDate zu GregorianCalendar
+            GregorianCalendar gregorianCalendar = GregorianCalendar.from(date.atStartOfDay(ZoneId.systemDefault()));
+
+            // Erstelle XMLGregorianCalendar mit Hilfe der DatatypeFactory
+            return DatatypeFactory.newInstance().newXMLGregorianCalendar(gregorianCalendar);
+        } catch (DatatypeConfigurationException e) {
+            e.printStackTrace();
+            return null; // Fehlerfall, falls die DatatypeFactory fehlschlägt
+        }
+    }
+}

client-lib/assembly.xml

@@ -0,0 +1,52 @@
+<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
+ 	<id>Doku</id>
+ 	<formats>
+  	<format>zip</format>
+  </formats>
+  	
+	<fileSets>
+		<!-- die Jars und die dlls einpacken -->
+		<fileSet>
+	    <directory>${project.build.directory}</directory>
+	    <outputDirectory>\</outputDirectory>
+	    <includes>
+	      <include>*dll</include>
+	      <include>*.jar</include>
+				<include>ReadMe.md</include>
+				<include>ReleaseNotes.md</include>
+	    </includes>
+	  </fileSet>
+
+		<fileSet>
+			<directory>${basedir}</directory>
+			<includes>
+				<include>ReadMe.md</include>
+				<include>ReleaseNotes.md</include>
+				<include>pom.xml</include>
+			</includes>
+		</fileSet>
+
+		<!-- Alles ausser bestimmte Dateitypen in doc (die manuell erstellte Dokumentation) -->
+  	<fileSet>
+			<excludes>
+				<exclude>%regex[(?!.*doc/).*tex]</exclude>
+				<exclude>%regex[(?!.*doc/).*png]</exclude>
+				<exclude>%regex[(?!.*doc/).*EAI.*]</exclude>
+			</excludes>
+			<directory>${basedir}\doc</directory>
+		</fileSet>
+
+		<!-- Alles in docGen (die mit XML-SPY generierte Dokumentation) -->
+		<fileSet>
+		  <directory>${basedir}\docGen</directory>
+		</fileSet>
+
+	  <fileSet>
+	  	<directory>${basedir}\src\main\resources\def\r2025_27</directory>
+	    <outputDirectory>/</outputDirectory>
+	  </fileSet>
+
+	</fileSets>
+ 
+</assembly>

client-lib/pom.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
     <groupId>com.kapdion.pisano</groupId>
@@ -12,16 +12,301 @@
   <artifactId>client-lib</artifactId>
 
   <properties>
+    <currentReleaseDir>r2025_27</currentReleaseDir>
+
     <maven.compiler.source>21</maven.compiler.source>
     <maven.compiler.target>21</maven.compiler.target>
+    <maven.compiler.release>21</maven.compiler.release>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
+    <maven.build.timestamp.format>yyyyMMdd</maven.build.timestamp.format>
+    <timestamp>${maven.build.timestamp}</timestamp>
   </properties>
 
   <dependencies>
+<!--    <dependency>-->
+<!--      <groupId>com.kapdion.pisano</groupId>-->
+<!--      <artifactId>api-definition</artifactId>-->
+<!--      <version>${project.version}</version>-->
+<!--    </dependency>-->
+
     <dependency>
-      <groupId>com.kapdion.pisano</groupId>
-      <artifactId>api-definition</artifactId>
-      <version>${project.version}</version>
+      <!-- https://mvnrepository.com/artifact/jakarta.xml.bind/jakarta.xml.bind-api -->
+      <!-- MIT License http://www.eclipse.org/org/documents/edl-v10.php -->
+      <groupId>jakarta.xml.bind</groupId>
+      <artifactId>jakarta.xml.bind-api</artifactId>
+      <version>4.0.2</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/jakarta.xml.soap/jakarta.xml.soap-api -->
+      <!-- MIT License http://www.eclipse.org/org/documents/edl-v10.php -->
+      <groupId>jakarta.xml.soap</groupId>
+      <artifactId>jakarta.xml.soap-api</artifactId>
+      <version>3.0.0</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/com.sun.xml.messaging.saaj/saaj-impl -->
+      <!-- MIT License http://www.eclipse.org/org/documents/edl-v10.php -->
+      <groupId>com.sun.xml.messaging.saaj</groupId>
+      <artifactId>saaj-impl</artifactId>
+      <version>3.0.4</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.glassfish.jaxb/jaxb-runtime -->
+      <!-- MIT License http://www.eclipse.org/org/documents/edl-v10.php -->
+      <groupId>org.glassfish.jaxb</groupId>
+      <artifactId>jaxb-runtime</artifactId>
+      <version>4.0.5</version>
+    </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.openjfx/javafx-controls -->
+      <!-- GPLv2+CE License https://openjdk.java.net/legal/gplv2+ce.html-->
+      <groupId>org.openjfx</groupId>
+      <artifactId>javafx-controls</artifactId>
+      <version>23.0.1</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.controlsfx/controlsfx -->
+      <!-- The 3-Clause BSD License http://www.opensource.org/licenses/bsd-license.php -->
+      <groupId>org.controlsfx</groupId>
+      <artifactId>controlsfx</artifactId>
+      <version>11.2.2</version>
+    </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.jvnet.jaxb2_commons/jaxb2-basics-annotate -->
+      <!-- BSD 2-Clause License http://opensource.org/licenses/BSD-2-Clause-->
+      <groupId>org.jvnet.jaxb2_commons</groupId>
+      <artifactId>jaxb2-basics-annotate</artifactId>
+      <version>1.1.0</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/com.sun.xml.ws/jaxws-maven-plugin -->
+      <!-- The Apache Software License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0.txt -->
+      <groupId>com.sun.xml.ws</groupId>
+      <artifactId>jaxws-maven-plugin</artifactId>
+      <version>4.0.3</version>
+    </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-restclient -->
+      <!-- The Apache Software License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0.txt -->
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-restclient</artifactId>
+      <version>4.0.0-M3</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
+      <!-- The Apache Software License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0.txt -->
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.20.0</version>
+    </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.eclipse.rdf4j/rdf4j-model -->
+      <!-- Eclipse Distribution License v1.0 https://eclipse.org/org/documents/edl-v10.php-->
+      <groupId>org.eclipse.rdf4j</groupId>
+      <artifactId>rdf4j-model</artifactId>
+      <version>5.1.5</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.eclipse.rdf4j/rdf4j-rio-turtle -->
+      <!-- Eclipse Distribution License v1.0 https://eclipse.org/org/documents/edl-v10.php-->
+      <groupId>org.eclipse.rdf4j</groupId>
+      <artifactId>rdf4j-rio-turtle</artifactId>
+      <version>5.1.5</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.eclipse.rdf4j/rdf4j-shacl -->
+      <!-- Eclipse Distribution License v1.0 https://eclipse.org/org/documents/edl-v10.php-->
+      <groupId>org.eclipse.rdf4j</groupId>
+      <artifactId>rdf4j-shacl</artifactId>
+      <version>5.1.5</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.eclipse.rdf4j/rdf4j-rio-jsonld -->
+      <!-- Eclipse Distribution License v1.0 https://eclipse.org/org/documents/edl-v10.php-->
+      <groupId>org.eclipse.rdf4j</groupId>
+      <artifactId>rdf4j-rio-jsonld</artifactId>
+      <version>5.1.5</version>
+    </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter -->
+      <!-- MIT License https://www.eclipse.org/legal/epl-v20.html -->
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <version>RELEASE</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
+      <!-- MIT License	http://www.opensource.org/licenses/mit-license.php -->
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>2.0.16</version>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-reload4j -->
+      <!-- MIT License	http://www.opensource.org/licenses/mit-license.php -->
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-reload4j</artifactId>
+      <version>2.0.16</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
+      <!-- MIT License	http://www.opensource.org/licenses/mit-license.php -->
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-simple</artifactId>
+      <version>2.0.16</version>
+      <scope>runtime</scope>
     </dependency>
   </dependencies>
+
+  <build>
+    <pluginManagement>
+      <plugins>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-source-plugin</artifactId>
+          <version>3.3.0</version>
+        </plugin>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-compiler-plugin</artifactId>
+          <version>3.12.1</version>
+        </plugin>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-assembly-plugin</artifactId>
+          <version>3.7.1</version>
+        </plugin>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-javadoc-plugin</artifactId>
+          <version>3.6.3</version>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <configuration>
+          <descriptors>
+            <descriptor>assembly.xml</descriptor>
+          </descriptors>
+        </configuration>
+        <executions>
+          <execution>
+            <id>make-assembly</id> <!-- this is used for inheritance merges -->
+            <phase>install</phase> <!-- bind to the install phase, damit source-jar und javadoc-jar mit eingepackt werden -->
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.3.1</version>
+        <configuration>
+          <archive>
+            <addMavenDescriptor>false</addMavenDescriptor>
+            <manifest>
+              <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+            </manifest>
+            <manifestEntries>
+              <!--						<Revision>${SVN_REVISION}</Revision>-->
+              <!--						<BuildTag>${BUILD_TAG}</BuildTag>-->
+              <BuildTimestamp>${maven.build.timestamp}</BuildTimestamp>
+              <JDKVersion>${maven.compiler.release}</JDKVersion>
+            </manifestEntries>
+          </archive>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.19.1</version>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>attach sources</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <configuration>
+          <doclint>reference</doclint>
+        </configuration>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.cxf</groupId>
+        <artifactId>cxf-codegen-plugin</artifactId>
+        <version>4.1.3</version>
+        <executions>
+          <execution>
+            <id>generate-sources</id>
+            <phase>generate-sources</phase>
+            <configuration>
+              <sourceRoot>${project.build.directory}/generated-sources/cxf</sourceRoot>
+              <wsdlOptions>
+                <wsdlOption>
+                  <wsdl>${project.basedir}/src/main/resources/def/${currentReleaseDir}/omds3Services.wsdl</wsdl>
+                  <extraargs>
+                    <extraarg>-xjc-Xannotate</extraarg>
+                    <extraarg>-client</extraarg>
+                    <extraarg>-impl</extraarg>
+                    <extraarg>-server</extraarg>
+                    <extraarg>-p</extraarg>
+                    <extraarg>at.vvo.omds.services</extraarg>
+                  </extraargs>
+                  <bindingFiles>
+                    <bindingFile>${project.basedir}/src/main/resources/def/${currentReleaseDir}/binding.xjb</bindingFile>
+                  </bindingFiles>
+                </wsdlOption>
+              </wsdlOptions>
+            </configuration>
+            <goals>
+              <goal>wsdl2java</goal>
+            </goals>
+          </execution>
+        </executions>
+        <dependencies>
+          <dependency>
+            <groupId>org.jvnet.jaxb</groupId>
+            <artifactId>jaxb-plugin-annotate</artifactId>
+            <version>3.0.0</version>
+          </dependency>
+        </dependencies>
+      </plugin>
+    </plugins>
+  </build>
 </project>

client-lib/src/main/java/at/vvo/omds/helpers/GuiProdukt.java

@@ -0,0 +1,32 @@
+package at.vvo.omds.helpers;
+
+public class GuiProdukt {
+    boolean notIncluded;
+    Object produkt;
+
+    public GuiProdukt(Object produkt) {
+        this.produkt = produkt;
+        this.notIncluded = false;
+    }
+
+    public GuiProdukt(Object produkt, boolean isNotIncluded) {
+        this.produkt = produkt;
+        this.notIncluded = isNotIncluded;
+    }
+
+    public boolean isNotIncluded() {
+        return notIncluded;
+    }
+
+    public void setNotIncluded(boolean notIncluded) {
+        this.notIncluded = notIncluded;
+    }
+
+    public Object getProdukt() {
+        return produkt;
+    }
+
+    public void setProdukt(Object produkt) {
+        this.produkt = produkt;
+    }
+}

client-lib/src/main/java/at/vvo/omds/helpers/ObjectFactoryFactory.java

@@ -0,0 +1,38 @@
+package at.vvo.omds.helpers;
+
+import at.vvo.omds.types.omds3.r2025_05.common.ProduktbausteinType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.ObjectFactory;
+
+public class ObjectFactoryFactory {
+    public ProduktbausteinType create(String classPath) {
+        if (classPath != null) {
+            if (classPath.toLowerCase().contains("kfz")){
+                ObjectFactory of = new ObjectFactory();
+                String typeName = classPath.substring(classPath.lastIndexOf(".") + 1);
+
+                return switch (typeName) {
+                    case "VerkaufsproduktKfzType" -> of.createVerkaufsproduktKfzType();
+                    case "HaftpflichtKfzType" -> of.createHaftpflichtKfzType();
+                    case "VollkaskoKfzType" -> of.createVollkaskoKfzType();
+                    case "AssistanceKfzType" -> of.createAssistanceKfzType();
+                    case "TeilkaskoKfzType" -> of.createTeilkaskoKfzType();
+                    case "InsassenUnfallKfzType" -> of.createInsassenUnfallKfzType();
+                    default -> null;
+                };
+            } else if (classPath.toLowerCase().contains("sachprivat")){
+                at.vvo.omds.types.omds3.r2025_05.on2antrag.sachPrivat.ObjectFactory of =
+                        new at.vvo.omds.types.omds3.r2025_05.on2antrag.sachPrivat.ObjectFactory();
+                String typeName = classPath.substring(classPath.lastIndexOf(".") + 1);
+
+                return switch (typeName) {
+                    case "VerkaufsproduktSachPrivatType" -> of.createVerkaufsproduktSachPrivatType();
+                    case "ProduktGebaeudeversicherungType" -> of.createProduktGebaeudeversicherungType();
+                    case "ProduktSachPrivatType" -> of.createProduktSachPrivatType();
+
+                    default -> null;
+                };
+            }
+        }
+        return null;
+    }
+}

client-lib/src/main/java/at/vvo/omds/helpers/Plausi.java

@@ -0,0 +1,44 @@
+package at.vvo.omds.helpers;
+
+public class Plausi {
+    String id;
+    String beschreibung;
+    String art;
+    String query;
+
+
+    public Plausi(String name, String beschreibung, String art, String query) {
+        this.id = name;
+        this.beschreibung = beschreibung;
+        this.art = art;
+        this.query = query;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getBeschreibung() {
+        return beschreibung;
+    }
+
+    public void setBeschreibung(String beschreibung) {
+        this.beschreibung = beschreibung;
+    }
+
+    public String getQuery() {
+        return query;
+    }
+
+    public void setQuery(String query) {
+        this.query = query;
+    }
+
+    public String getArt() { return art; }
+
+    public void setArt(String art) { this.art = art; }
+}

client-lib/src/main/java/at/vvo/omds/helpers/RDFHelper.java

@@ -0,0 +1,660 @@
+package at.vvo.omds.helpers;
+
+import at.vvo.omds.types.omds3.r2025_05.common.*;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.sachPrivat.RisikoGebaeudeType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.sachPrivat.RisikoHaushaltType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.sachPrivat.VersichertesObjektSachPrivatType;
+import jakarta.xml.bind.JAXBElement;
+import javafx.scene.control.TreeItem;
+import javafx.util.Pair;
+import org.eclipse.rdf4j.model.*;
+import org.eclipse.rdf4j.model.impl.LinkedHashModel;
+import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
+import org.eclipse.rdf4j.model.util.Models;
+import org.eclipse.rdf4j.model.util.Values;
+import org.eclipse.rdf4j.model.vocabulary.RDF;
+import org.eclipse.rdf4j.rio.RDFFormat;
+import org.eclipse.rdf4j.rio.Rio;
+import org.springframework.http.MediaType;
+import org.springframework.web.client.RestClient;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.io.IOException;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+import static org.eclipse.rdf4j.model.util.Values.iri;
+
+public class RDFHelper {
+
+    private final RestClient restClient = RestClient.create();
+
+    public Pair<List<APrioriVerkaufsproduktType>, List<Plausi>> getAprioriRDF(JAXBElement<ProductsRequest> r) throws DatatypeConfigurationException, IOException {
+        String response = restClient.post()
+                .uri("http://localhost:9090/ProductsRequest")
+                .contentType(MediaType.APPLICATION_JSON)
+                .body(r.getValue())
+                .retrieve()
+                .toEntity(String.class)
+                .getBody();
+
+
+        List<Pair<String, AttributType>> attributeListe = getAttributesFromRequest(response);
+        List<APrioriVerkaufsproduktType> result = productsRequestToVerkaufsprodukt(response, attributeListe);
+        List<Plausi> result2 = productsRequestToPlausi(response);
+
+        return new Pair<>(result, result2);
+    }
+
+    private List<Pair<String, AttributType>> getAttributesFromRequest(String response) throws IOException {
+        Model model = Rio.parse(new StringReader(response), "", RDFFormat.JSONLD);
+        List<Pair<String, AttributType>> erg = new ArrayList<>();
+
+        String baseIri = "http://vvo.pisanoapi.at/";
+
+        IRI bezIri = iri(baseIri + "bez");
+        IRI produktIri = iri(baseIri + "ProdElement");
+        IRI requiredIri = iri(baseIri + "required");
+        IRI maxIri = iri(baseIri + "max");
+        IRI minIri = iri(baseIri + "min");
+        IRI defaultIri = iri(baseIri + "default");
+        IRI valueIri = iri(baseIri + "value");
+        IRI aenderbarIri = iri(baseIri + "aenderbar");
+
+
+        for (Resource iri : Models.subjectIRIs(model)) {
+            String bez = Models.objectLiteral(model.filter(iri, bezIri, null)).map(Literal::getLabel).orElse(null);
+            String prodId = Models.objectResource(model.filter(iri, produktIri, null)).map(Resource::stringValue)
+                    .orElse(Models.objectLiteral(model.filter(iri, produktIri, null)).map(Literal::getLabel).orElse(null));
+            Boolean required = Boolean.valueOf(Models.objectLiteral(model.filter(iri, requiredIri, null)).map(Literal::getLabel).orElse(null));
+            Boolean aenderbar = Boolean.valueOf(Models.objectLiteral(model.filter(iri, aenderbarIri, null)).map(Literal::getLabel).orElse("true"));
+
+            if (iri.stringValue().contains("ElemBoolean")) {
+                AttributBooleanType ab = new AttributBooleanType();
+
+                Boolean val = Boolean.valueOf(Models.objectLiteral(model.filter(iri, valueIri, null)).map(Literal::getLabel).orElse(null));
+                Boolean def = Boolean.valueOf(Models.objectLiteral(model.filter(iri, defaultIri, null)).map(Literal::getLabel).orElse(null));
+
+                int start = iri.stringValue().lastIndexOf("ElemBoolean");
+                ab.setId(BigInteger.valueOf(Long.valueOf(iri.stringValue().substring(start + "ElemBoolean".length()))));
+
+                ab.setBezeichnung(bez);
+                ab.setDefault(def);
+                ab.setPflichtfeld(required);
+                ab.setValue(val);
+                ab.setAenderbar(aenderbar);
+
+                Pair<String, AttributType> atPair = new Pair<>(prodId, ab);
+                erg.add(atPair);
+            } else if (iri.stringValue().contains("ElemInt")) {
+                AttributIntType ai = new AttributIntType();
+
+                Integer val = Integer.parseInt(Models.objectLiteral(model.filter(iri, valueIri, null)).map(Literal::getLabel).orElse("-1"));
+                Integer def = Integer.parseInt(Models.objectLiteral(model.filter(iri, defaultIri, null)).map(Literal::getLabel).orElse("-1"));
+                Integer min = Integer.parseInt(Models.objectLiteral(model.filter(iri, minIri, null)).map(Literal::getLabel).orElse("-1"));
+                Integer max = Integer.parseInt(Models.objectLiteral(model.filter(iri, maxIri, null)).map(Literal::getLabel).orElse("-1"));
+
+                int start = iri.stringValue().lastIndexOf("ElemInt");
+                ai.setId(BigInteger.valueOf(Long.parseLong(iri.stringValue().substring(start + "ElemInt".length()))));
+
+                ai.setBezeichnung(bez);
+                ai.setDefault(def);
+                ai.setPflichtfeld(required);
+                ai.setMax(max);
+                ai.setMin(min);
+                if (!val.equals(-1))ai.setValue(val);
+                ai.setAenderbar(aenderbar);
+
+                Pair<String, AttributType> atPair = new Pair<>(prodId, ai);
+                erg.add(atPair);
+            } else if (iri.stringValue().contains("ElemDecimal")) {
+                AttributDezimalType ad = new AttributDezimalType();
+
+                BigDecimal val = Models.objectLiteral(model.filter(iri, valueIri, null)).map(Literal::decimalValue).orElse(BigDecimal.valueOf(-1));
+                BigDecimal def = Models.objectLiteral(model.filter(iri, defaultIri, null)).map(Literal::decimalValue).orElse(BigDecimal.valueOf(-1));
+                BigDecimal min = Models.objectLiteral(model.filter(iri, minIri, null)).map(Literal::decimalValue).orElse(BigDecimal.valueOf(-1));
+                BigDecimal max = Models.objectLiteral(model.filter(iri, maxIri, null)).map(Literal::decimalValue).orElse(BigDecimal.valueOf(-1));
+
+                int start = iri.stringValue().lastIndexOf("ElemDecimal");
+                ad.setId(BigInteger.valueOf(Long.valueOf(iri.stringValue().substring(start + "ElemDecimal".length()))));
+
+                ad.setBezeichnung(bez);
+                ad.setDefault(def);
+                ad.setPflichtfeld(required);
+                ad.setMax(max);
+                ad.setMin(min);
+                if (!val.equals(BigDecimal.valueOf(-1)))ad.setValue(val);
+                ad.setAenderbar(aenderbar);
+
+                Pair<String, AttributType> atPair = new Pair<>(prodId, ad);
+                erg.add(atPair);
+            } else if (iri.stringValue().contains("ElemString")) {
+                AttributStringType as = new AttributStringType();
+
+                String val = String.valueOf(Models.objectLiteral(model.filter(iri, valueIri, null)).map(Literal::getLabel).orElse(null));
+                String def = String.valueOf(Models.objectLiteral(model.filter(iri, defaultIri, null)).map(Literal::getLabel).orElse(null));
+
+                int start = iri.stringValue().lastIndexOf("ElemString");
+                as.setId(BigInteger.valueOf(Long.parseLong(iri.stringValue().substring(start + "ElemString".length()))));
+
+                as.setBezeichnung(bez);
+                as.setDefault(def);
+                as.setPflichtfeld(required);
+                as.setValue(val);
+                as.setAenderbar(aenderbar);
+
+                Pair<String, AttributType> atPair = new Pair<>(prodId, as);
+                erg.add(atPair);
+            }
+        }
+
+        return erg;
+    }
+
+    private List<Plausi> productsRequestToPlausi(String response) throws IOException {
+        List<Plausi> result = new ArrayList<>();
+        Model model = Rio.parse(new StringReader(response), "", RDFFormat.JSONLD);
+
+        for (Resource iri : Models.subjectIRIs(model)) {
+            if (iri.stringValue().contains("Plausi")) {
+                String id = iri.stringValue().replace("http://vvo.pisanoapi.at/Plausi", "");
+                ValueFactory vf = SimpleValueFactory.getInstance();
+
+                String beschreibung = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/beschreibung"), null)).map(Literal::getLabel).orElse(null);
+
+                String query = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/query"), null)).map(Literal::getLabel).orElse(null);
+
+                String art = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/art"), null)).map(Literal::getLabel).orElse(null);
+
+                result.add(new Plausi(id, beschreibung, art, query));
+            }
+        }
+        return result;
+    }
+
+    private List<APrioriVerkaufsproduktType> productsRequestToVerkaufsprodukt(String productsRequest, List<Pair<String, AttributType>> attributeListe) throws IOException, DatatypeConfigurationException {
+        Model model = Rio.parse(new StringReader(productsRequest), "", RDFFormat.JSONLD);
+
+        Map<String, APrioriProduktbausteinType> bausteine = new HashMap<>();
+        Map<String, String> parents = new HashMap<>();
+
+        for (Resource iri : Models.subjectIRIs(model)) {
+            if (iri.stringValue().contains("ProdElement")) {
+
+                String id = iri.stringValue();
+                ValueFactory vf = SimpleValueFactory.getInstance();
+
+                int insId = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/ins_id"), null)).map(Literal::getLabel).orElse("-1"));
+                int maxOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/maxOccurrence"), null)).map(Literal::getLabel).orElse("-1"));
+                int minOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/minOccurrence"), null)).map(Literal::getLabel).orElse("-1"));
+                String bez = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/bez"), null)).map(Literal::getLabel).orElse(null);
+                String type = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/type"), null)).map(Literal::getLabel).orElse(null);
+                String risikoobjektType = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/risikoobjektType"), null)).map(Literal::getLabel).orElse(null);
+                String praemie = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/praemienfaktor"), null)).map(Literal::getLabel).orElse(null);
+                XMLGregorianCalendar verkaufsoffenVon = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).isPresent() ?
+                        DatatypeFactory.newInstance().newXMLGregorianCalendar( Models.objectLiteral(model.filter(
+                                iri, vf.createIRI("http://vvo.pisanoapi.at/salesFrom"), null))
+                                .map(Literal::getLabel).orElse(null)) : null;
+                XMLGregorianCalendar verkaufsoffenBis = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).isPresent() ?
+                        DatatypeFactory.newInstance().newXMLGregorianCalendar( Models.objectLiteral(model.filter(
+                                iri, vf.createIRI("http://vvo.pisanoapi.at/salesTo"), null))
+                                .map(Literal::getLabel).orElse(null)) : null;
+
+                Optional<String> parentId = Models.objectResource(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/Parent"), null)).map(Resource::stringValue);
+
+                APrioriProduktbausteinType verkaufsproduktType;
+                if (parentId.isPresent()) {
+                    verkaufsproduktType = new APrioriUnterbausteinType();
+                } else {
+                    verkaufsproduktType = new APrioriVerkaufsproduktType();
+                }
+
+                for (Pair<String, AttributType> attribute : attributeListe) {
+                    if (attribute.getKey().equals(id)){
+                        verkaufsproduktType.getAttribute().add(attribute.getValue());
+                    }
+                }
+
+                verkaufsproduktType.setId(iri.stringValue().substring("http://vvo.pisanoapi.at/ProdElement".length(), iri.stringValue().indexOf("-") > 0 ? iri.stringValue().indexOf("-") : iri.stringValue().length()));
+                verkaufsproduktType.setName(bez);
+                verkaufsproduktType.setType(type);
+                verkaufsproduktType.setFrom(verkaufsoffenVon);
+                verkaufsproduktType.setTo(verkaufsoffenBis);
+                verkaufsproduktType.setMaxOccurrences(maxOccurrence);
+                verkaufsproduktType.setMinOccurrences(minOccurrence);
+                verkaufsproduktType.setRisikoobjektType(risikoobjektType);
+                verkaufsproduktType.setPraemienfaktor(praemie);
+
+                parentId.ifPresent(p -> parents.put(id, p));
+                bausteine.put(id, verkaufsproduktType);
+            }
+        }
+
+        List<APrioriVerkaufsproduktType> verkaufsprodukteList = new ArrayList<>();
+
+        for (Map.Entry<String, APrioriProduktbausteinType> entry : bausteine.entrySet()){
+            String id = entry.getKey();
+            Object baustein = entry.getValue();
+            String parentId = parents.get(id);
+
+            if (parentId != null && bausteine.containsKey(parentId)){
+                bausteine.get(parentId).getBausteine().add((APrioriUnterbausteinType) baustein);
+            }else {
+                verkaufsprodukteList.add((APrioriVerkaufsproduktType) baustein);
+            }
+        }
+
+        return verkaufsprodukteList;
+    }
+
+    public VerkaufsproduktType getCalculateRDF(String r) throws DatatypeConfigurationException, IOException {
+        return calculateRequestToVerkaufsprodukt(restClient.post()
+                .uri("http://localhost:9090/CalculateRequest")
+                .contentType(MediaType.APPLICATION_JSON)
+                .body(r)
+                .retrieve()
+                .toEntity(String.class)
+                .getBody());
+    }
+
+    public VerkaufsproduktType calculateRequestToVerkaufsprodukt(String calculateRequest) throws IOException, DatatypeConfigurationException {
+        Model model = Rio.parse(new StringReader(calculateRequest), "", RDFFormat.JSONLD);
+
+        Map<String, ProduktbausteinType> bausteine = new LinkedHashMap<>();
+        Map<String, String> parents = new HashMap<>();
+
+        List<Pair<String, AttributType>> attListe = getAttributesFromRequest(calculateRequest);
+        List<Pair<String, FahrzeugType>> risikoObjektListe = getRisikoObjekteFromRequest(calculateRequest);
+
+        List<Resource> subjects = new ArrayList<>(Models.subjectIRIs(model));
+        Collections.reverse(subjects);
+
+        for (Resource iri : subjects) {
+            if (iri.stringValue().contains("Prod")) {
+                String id = iri.stringValue();
+
+                ValueFactory vf = SimpleValueFactory.getInstance();
+
+                int insId = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/ins_id"), null)).map(Literal::getLabel).orElse("-1"));
+                int maxOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/maxOccurrence"), null)).map(Literal::getLabel).orElse("-1"));
+                int minOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/minOccurrence"), null)).map(Literal::getLabel).orElse("-1"));
+                String bez = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/bez"), null)).map(Literal::getLabel).orElse(null);
+                String type = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/type"), null)).map(Literal::getLabel).orElse(null);
+                String risikoobjektType = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/risikoobjektType"), null)).map(Literal::getLabel).orElse(null);
+                String praemie = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/praemienfaktor"), null)).map(Literal::getLabel).orElse(null);
+                List<ServiceFault> meldungen = model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/Meldung"), null).objects().stream()
+                        .filter(s -> s instanceof IRI).map(s -> {
+                            IRI spezMeldung = (IRI) s;
+
+                            String msg = Models.objectLiteral(model.filter(spezMeldung, vf.createIRI("http://vvo.pisanoapi.at/errorMsg"), null)).map(Literal::getLabel).orElse(null);
+                            String errorType = Models.objectLiteral(model.filter(spezMeldung, vf.createIRI("http://vvo.pisanoapi.at/errorType"), null)).map(Literal::getLabel).orElse(null);
+
+                            ServiceFault serviceFault = new ServiceFault();
+
+                            serviceFault.setErrorMsg(msg);
+                            serviceFault.setErrorType(BigInteger.valueOf(Integer.parseInt("1")));
+
+                            return serviceFault;
+                        }).toList();
+                XMLGregorianCalendar verkaufsoffenVon = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).isPresent() ? DatatypeFactory.newInstance().newXMLGregorianCalendar(
+                        Models.objectLiteral(model.filter(iri, vf.createIRI(
+                                "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).orElse(null)) : null;
+                XMLGregorianCalendar verkaufsoffenBis = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).isPresent() ? DatatypeFactory.newInstance().newXMLGregorianCalendar(
+                        Models.objectLiteral(model.filter(iri, vf.createIRI(
+                                "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).orElse(null)) : null;
+                List<String> fahrzeuge = model.filter(iri, vf.createIRI(
+                                "http://vvo.pisanoapi.at/VersichertesInteresseType"), null).objects().stream()
+                        .filter(s -> s instanceof IRI).map(Value::stringValue).toList();
+
+                Optional<String> parentId = Models.objectResource(model.filter(iri, vf.createIRI(
+                        "http://vvo.pisanoapi.at/Parent"), null)).map(Resource::stringValue);
+                if (parentId.isEmpty()) {
+                    parentId = Models.objectLiteral(model.filter(iri, vf.createIRI(
+                            "http://vvo.pisanoapi.at/Parent"), null)).map(Literal::getLabel);
+                }
+
+                ObjectFactoryFactory off = new ObjectFactoryFactory();
+
+                ProduktbausteinType verkaufsproduktType = off.create(type);
+
+                verkaufsproduktType.setId(iri.stringValue().substring("http://vvo.pisanoapi.at/ProdElement".length(), iri.stringValue().indexOf("-") > 0 ? iri.stringValue().indexOf("-") : iri.stringValue().length()));
+                verkaufsproduktType.setBezeichnung(bez);
+                verkaufsproduktType.setTyp(type);
+                verkaufsproduktType.setVerkaufsoffenVon(verkaufsoffenVon);
+                verkaufsproduktType.setVerkaufsoffenBis(verkaufsoffenBis);
+                verkaufsproduktType.setMaxVorkommen(maxOccurrence);
+                verkaufsproduktType.setMinVorkommen(minOccurrence);
+                verkaufsproduktType.setRisikoobjektErforderlich(risikoobjektType != null);
+                verkaufsproduktType.setPraemienfaktor(praemie);
+
+                for (ServiceFault meldung : meldungen) {
+                    if (meldung != null) {
+                        ServiceFault tmp = new ServiceFault();
+                        tmp.setErrorMsg(meldung.getErrorMsg());
+                        tmp.setErrorType(meldung.getErrorType());
+                        verkaufsproduktType.getMeldungen().add(tmp);
+                    }
+                }
+
+                for (Pair<String, FahrzeugType> pair : risikoObjektListe) {
+                    for (String fahrzeugId : fahrzeuge) {
+                        if (pair.getKey().equals(fahrzeugId)) {
+                            verkaufsproduktType.getVersicherteObjekte().add(pair.getValue());
+                        }
+                    }
+                }
+
+                for (Pair<String, AttributType> pair : attListe) {
+                    if (pair.getKey().equals(id)) {
+                        verkaufsproduktType.getAttribute().add(pair.getValue());
+                    }
+                }
+
+                parentId.ifPresent(p -> parents.put(id, p));
+                bausteine.put(id, verkaufsproduktType);
+            }
+        }
+
+        List<VerkaufsproduktType> verkaufsprodukteList = new ArrayList<>();
+
+
+        for (Map.Entry<String, ProduktbausteinType> entry : bausteine.entrySet()){
+            String id = entry.getKey();
+            ProduktbausteinType baustein = entry.getValue();
+            String parentId = parents.get(id);
+
+            if (parentId != null && bausteine.containsKey(parentId)){
+                bausteine.get(parentId).getBausteine().add(baustein);
+            }else {
+                verkaufsprodukteList.add((VerkaufsproduktType) baustein);
+            }
+        }
+
+        return verkaufsprodukteList.getFirst();
+    }
+
+    private List<Pair<String, FahrzeugType>> getRisikoObjekteFromRequest(String calculateRequest) throws IOException, DatatypeConfigurationException {
+        Model model = Rio.parse(new StringReader(calculateRequest), "", RDFFormat.JSONLD);
+        List<Pair<String, FahrzeugType>> erg = new ArrayList<>();
+
+        String baseIri = "http://vvo.pisanoapi.at/";
+        IRI bezIri = iri(baseIri + "bez");
+        IRI baujahrIri = iri(baseIri + "baujahr");
+        IRI erstzulassungIri = iri(baseIri + "erstzulassung");
+        IRI kenIri = iri(baseIri + "kennzeichen");
+        IRI leistungIri = iri(baseIri + "leistung");
+        IRI sonderIri = iri(baseIri + "sonderausstattung");
+        IRI listenpreisIri = iri(baseIri + "listenpreis");
+
+
+        for (Resource iri : Models.subjectIRIs(model)) {
+            if (iri.stringValue().contains("Fahrzeug")) {
+                String id = iri.stringValue();
+
+                String bez = Models.objectLiteral(
+                        model.filter(iri, bezIri, null)).map(Literal::getLabel).orElse(null);
+                String ken = Models.objectLiteral(
+                        model.filter(iri, kenIri, null)).map(Literal::getLabel).orElse(null);
+                BigDecimal listenpreis = BigDecimal.valueOf(
+                        Double.parseDouble(Models.objectLiteral(model.filter(iri, listenpreisIri, null))
+                                .map(Literal::getLabel).orElse("-1")));
+                BigDecimal sonderausstattung = BigDecimal.valueOf(
+                        Double.parseDouble(Models.objectLiteral(model.filter(iri, sonderIri, null))
+                                .map(Literal::getLabel).orElse("-1")));
+
+                int leistung = Integer.parseInt(Models.objectLiteral(
+                        model.filter(iri, leistungIri, null)).map(Literal::getLabel).orElse("-1"));
+                int baujahr = Integer.parseInt(Models.objectLiteral(
+                        model.filter(iri, baujahrIri, null)).map(Literal::getLabel).orElse("-1"));
+
+                XMLGregorianCalendar erstzulassung = Models.objectLiteral(model.filter(
+                        iri, erstzulassungIri, null)).map(Literal::getLabel).isPresent() ?
+                        DatatypeFactory.newInstance().newXMLGregorianCalendar(
+                        Models.objectLiteral(model.filter(iri, erstzulassungIri, null))
+                                .map(Literal::getLabel).orElse(null)) : null;
+
+                FahrzeugType fahrzeug = new FahrzeugType();
+
+                fahrzeug.setErstzulassdat(erstzulassung);
+                fahrzeug.setBaujahr(baujahr);
+                fahrzeug.setHandelsbez(bez);
+                fahrzeug.setPolKennz(ken);
+                fahrzeug.setLeistung(leistung);
+                fahrzeug.setListenpreis(listenpreis);
+                fahrzeug.setSonderausstattung(sonderausstattung);
+
+                erg.add(new Pair<>(id, fahrzeug));
+            }
+        }
+        return erg;
+    }
+
+    public Model createRdfModel(TreeItem<GuiProdukt> vp) {
+        Model erg = new LinkedHashModel();
+        String baseIri = "http://vvo.pisanoapi.at/";
+
+        Map<String, Integer> idCount = new LinkedHashMap<>();
+        createIdCount(idCount, vp);
+
+        Map<TreeItem<GuiProdukt>, IRI> iriMap = new LinkedHashMap<>();
+        createIriMap(vp, baseIri, idCount, iriMap);
+
+        addProduktToModel(vp, erg, baseIri, null, iriMap);
+
+        return erg;
+    }
+
+    private void createIdCount(Map<String, Integer> idCount, TreeItem<GuiProdukt> vp) {
+        if (!idCount.containsKey(((ProduktbausteinType) vp.getValue().getProdukt()).getId())) {
+            idCount.put(((ProduktbausteinType) vp.getValue().getProdukt()).getId(), 1);
+        }else {
+            idCount.put(((ProduktbausteinType) vp.getValue().getProdukt()).getId(), idCount.get(((ProduktbausteinType) vp.getValue().getProdukt()).getId()) + 1);
+        }
+
+        for (TreeItem<GuiProdukt> child : vp.getChildren()){
+            createIdCount(idCount, child);
+        }
+
+    }
+
+    private void createIriMap(TreeItem<GuiProdukt> produkt, String baseIri, Map<String, Integer> idCount, Map<TreeItem<GuiProdukt>, IRI> iriMap) {
+        IRI baseElemIri = iri(baseIri + "ProdElement");
+
+        for (int i = 1; i < idCount.get(((ProduktbausteinType)produkt.getValue().getProdukt()).getId())+1; i++) {
+            IRI tmpIri = iri(baseElemIri + ((ProduktbausteinType) produkt.getValue().getProdukt()).getId() + "-" + i);
+
+            if (!iriMap.containsValue(tmpIri)) {
+                iriMap.put(produkt, tmpIri);
+                break;
+            }
+        }
+
+        for (TreeItem<GuiProdukt> child : produkt.getChildren()){
+            createIriMap(child, baseIri, idCount, iriMap);
+        }
+
+    }
+
+    public void addProduktToModel(TreeItem<GuiProdukt> guiProdukt, Model model, String baseIri, String parentId, Map<TreeItem<GuiProdukt>, IRI> iriMap) {
+        ProduktbausteinType produkt = (ProduktbausteinType) guiProdukt.getValue().getProdukt();
+
+        IRI prodelemIri = iri(baseIri + "ProdElement");
+        IRI insIdIri = iri(baseIri + "ins_id");
+        IRI bezIri = iri(baseIri + "bez");
+        IRI createdIri = iri(baseIri + "created");
+        IRI salesFromIri = iri(baseIri + "salesFrom");
+        IRI salesToIri = iri(baseIri + "salesTo");
+        IRI minOccurrenceIri = iri(baseIri + "minOccurrence");
+        IRI maxOccurrenceIri = iri(baseIri + "maxOccurrence");
+        IRI typeIri = iri(baseIri + "type");
+        IRI risikoobjektTypeIri = iri(baseIri + "risikoobjektType");
+        IRI bausteinIri = iri(baseIri + "Baustein");
+        IRI parentIri = iri(baseIri + "Parent");
+        IRI praemieIri = iri(baseIri + "praemienfaktor");
+
+        IRI vpIri = iriMap.get(guiProdukt);
+
+        if (!guiProdukt.getValue().isNotIncluded()) {
+            model.add(vpIri, RDF.TYPE, prodelemIri);
+            model.add(vpIri, bezIri, Values.literal(produkt.getBezeichnung()));
+            if (produkt.getVerkaufsoffenVon() != null)
+                model.add(vpIri, salesFromIri, Values.literal(produkt.getVerkaufsoffenVon()));
+            if (produkt.getVerkaufsoffenBis() != null)
+                model.add(vpIri, salesToIri, Values.literal(produkt.getVerkaufsoffenBis()));
+            if (produkt.getMinVorkommen() != null)
+                model.add(vpIri, minOccurrenceIri, Values.literal(produkt.getMinVorkommen()));
+            if (produkt.getMaxVorkommen() != null)
+                model.add(vpIri, maxOccurrenceIri, Values.literal(produkt.getMaxVorkommen()));
+            model.add(vpIri, typeIri, Values.literal(produkt.getTyp()));
+            if (produkt.isRisikoobjektErforderlich()) model.add(vpIri, risikoobjektTypeIri, Values.literal("FahrzeugType"));
+            if (produkt.getPraemienfaktor() != null) model.add(vpIri, praemieIri, Values.literal(produkt.getPraemienfaktor()));
+            if (parentId != null) model.add(vpIri, parentIri, Values.iri(parentId));
+
+        }
+
+        for (AttributType attribut : produkt.getAttribute()){
+            IRI atBez = iri(baseIri + "bez");
+            IRI atRequiredIri = iri(baseIri + "required");
+            IRI atProd = iri(baseIri + "ProdElement");
+            IRI atValue = iri(baseIri + "value");
+            IRI atMax = iri(baseIri + "max");
+            IRI atMin = iri(baseIri + "min");
+            IRI atDefault = iri(baseIri + "default");
+            IRI atAenderbar = iri(baseIri + "aenderbar");
+
+            if (attribut instanceof AttributIntType){
+                IRI specificAt = iri(baseIri + "ElemInt" + attribut.getId());
+
+                model.add(specificAt, RDF.TYPE, iri(baseIri + "ElemInt"));
+                model.add(specificAt, atBez, Values.literal(attribut.getBezeichnung()));
+                model.add(specificAt, atRequiredIri, Values.literal(((AttributIntType) attribut).isPflichtfeld()));
+                if (((AttributIntType) attribut).getValue() != null) model.add(specificAt, atValue, Values.literal(((AttributIntType) attribut).getValue()));
+                model.add(specificAt, atProd, vpIri);
+                model.add(specificAt, atMax, Values.literal(((AttributIntType) attribut).getMax()));
+                model.add(specificAt, atMin, Values.literal(((AttributIntType) attribut).getMin()));
+                model.add(specificAt, atDefault, Values.literal(((AttributIntType) attribut).getDefault()));
+                model.add(specificAt, atAenderbar, Values.literal(attribut.isAenderbar() != null ? attribut.isAenderbar().toString() : true));
+
+            } else if (attribut instanceof AttributBooleanType) {
+                IRI specificAt = iri(baseIri + "ElemBoolean" + attribut.getId());
+
+                model.add(specificAt, RDF.TYPE, iri(baseIri + "ElemBoolean"));
+                model.add(specificAt, atBez, Values.literal(attribut.getBezeichnung()));
+                model.add(specificAt, atRequiredIri, Values.literal(((AttributBooleanType) attribut).isPflichtfeld()));
+                if (((AttributBooleanType) attribut).isValue() != null) model.add(specificAt, atValue, Values.literal(((AttributBooleanType) attribut).isValue()));
+                model.add(specificAt, atProd, vpIri);
+                model.add(specificAt, atDefault, Values.literal(((AttributBooleanType) attribut).isDefault()));
+
+            } else if (attribut instanceof AttributStringType) {
+                IRI specificAt = iri(baseIri + "ElemString" + attribut.getId());
+
+                model.add(specificAt, RDF.TYPE, iri(baseIri + "ElemString"));
+                model.add(specificAt, atBez, Values.literal(attribut.getBezeichnung()));
+                model.add(specificAt, atRequiredIri, Values.literal(((AttributStringType) attribut).isPflichtfeld()));
+                if (((AttributStringType) attribut).getValue() != null) model.add(specificAt, atValue, Values.literal(((AttributStringType) attribut).getValue()));
+                model.add(specificAt, atProd, vpIri);
+                model.add(specificAt, atDefault, Values.literal(((AttributStringType) attribut).getDefault()));
+
+            } else if (attribut instanceof AttributDezimalType) {
+                IRI specificAt = iri(baseIri + "ElemDecimal" + attribut.getId());
+
+                model.add(specificAt, RDF.TYPE, iri(baseIri + "ElemDecimal"));
+                model.add(specificAt, atBez, Values.literal(attribut.getBezeichnung()));
+                model.add(specificAt, atRequiredIri, Values.literal(((AttributDezimalType) attribut).isPflichtfeld()));
+                if (((AttributDezimalType) attribut).getValue() != null) model.add(specificAt, atValue, Values.literal(((AttributDezimalType) attribut).getValue()));
+                model.add(specificAt, atProd, vpIri);
+                if (((AttributDezimalType) attribut).getMax() != null) model.add(specificAt, atMax, Values.literal(((AttributDezimalType) attribut).getMax()));
+                if (((AttributDezimalType) attribut).getMin() != null) model.add(specificAt, atMin, Values.literal(((AttributDezimalType) attribut).getMin()));
+                if (((AttributDezimalType) attribut).getDefault() != null) model.add(specificAt, atDefault, Values.literal(((AttributDezimalType) attribut).getDefault()));
+            }
+        }
+
+        int meldungId = 1;
+        for (ServiceFault sf : produkt.getMeldungen()){
+            IRI meldung = iri(baseIri + "Meldung");
+            IRI spezMeldung = iri(baseIri + "Meldung" + meldungId);
+            IRI meldungMsg = iri(baseIri + "errorMsg");
+            IRI meldungType = iri(baseIri + "errorType");
+
+            model.add(vpIri, meldung, spezMeldung);
+            model.add(spezMeldung, meldungMsg, Values.literal(sf.getErrorMsg()));
+            model.add(spezMeldung, meldungType, Values.literal(sf.getErrorType()));
+
+            meldungId++;
+        }
+
+        for (VersichertesInteresseType ro : produkt.getVersicherteObjekte()){
+            if (ro instanceof FahrzeugType fa){
+                IRI fahrzeugIri = iri(baseIri + "FahrzeugType");
+                IRI faIri = iri(fahrzeugIri.stringValue() + fa.getHandelsbez() + fa.getBaujahr());
+                IRI faBaujahrIri = iri(baseIri + "baujahr");
+                IRI faBezIri = iri(baseIri + "bez");
+                IRI faErstZuIri = iri(baseIri + "erstzulassung");
+                IRI faKennIri = iri(baseIri + "kennzeichen");
+                IRI faLpreisIri = iri(baseIri + "listenpreis");
+                IRI faSonderIri = iri(baseIri + "sonderausstattung");
+                IRI faLeistungIri = iri(baseIri + "leistung");
+                IRI prodRoIri = iri(baseIri + "VersichertesInteresseType");
+
+                model.add(faIri, RDF.TYPE, fahrzeugIri);
+                model.add(faIri, faBaujahrIri, Values.literal(fa.getBaujahr()));
+                model.add(faIri, faBezIri, Values.literal(fa.getHandelsbez()));
+                model.add(faIri, faErstZuIri, Values.literal(fa.getErstzulassdat()));
+                model.add(faIri, faKennIri, Values.literal(fa.getPolKennz()));
+                model.add(faIri, faLpreisIri, Values.literal(fa.getListenpreis()));
+                model.add(faIri, faSonderIri, Values.literal(fa.getSonderausstattung()));
+                model.add(faIri, faLeistungIri, Values.literal(fa.getLeistung()));
+
+                model.add(vpIri, prodRoIri, faIri);
+
+            } else if (ro instanceof  VersicherteLiegenschaftType) {
+                //To-Do
+            } else if (ro instanceof RisikoGebaeudeType) {
+                //To-Do
+            }else if (ro instanceof RisikoHaushaltType) {
+                //To-Do
+            }else if (ro instanceof VersichertePersonType) {
+                //To-Do
+            }else if (ro instanceof VersichertesObjektSachPrivatType) {
+                //To-Do
+            }
+        }
+
+        for (int i = 0; i < guiProdukt.getChildren().size(); i++) {
+            IRI unterbausteinIri = iriMap.get(guiProdukt.getChildren().get(i));
+            if (!guiProdukt.getValue().isNotIncluded()) {
+                model.add(vpIri, bausteinIri, unterbausteinIri);
+            }
+
+            String newParentId = vpIri.stringValue();
+            addProduktToModel(guiProdukt.getChildren().get(i), model, baseIri, newParentId, iriMap);
+        }
+    }
+}

client-lib/src/main/java/at/vvo/omds/helpers/TreeHelper.java

@@ -0,0 +1,204 @@
+package at.vvo.omds.helpers;
+
+import at.vvo.omds.types.omds3.r2025_05.common.APrioriProduktbausteinType;
+import at.vvo.omds.types.omds3.r2025_05.common.ProduktbausteinType;
+import javafx.collections.FXCollections;
+import javafx.scene.control.TreeItem;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+public class TreeHelper {
+    Map<String, Integer> timesItemisIncludedById = new HashMap<>();
+
+    public Map<String, Integer> getTimesItemisIncludedById() {
+        return timesItemisIncludedById;
+    }
+
+    public void setTimesItemisIncludedById(Map<String, Integer> timesItemisIncludedById) {
+        this.timesItemisIncludedById = timesItemisIncludedById;
+    }
+
+    public TreeItem<GuiProdukt> cleanTree(TreeItem<GuiProdukt> original) {
+        if (original.getValue().isNotIncluded()) {
+            return null;
+        }
+
+        TreeItem<GuiProdukt> newItem = new TreeItem<>(original.getValue());
+        for (TreeItem<GuiProdukt> child : original.getChildren()) {
+            TreeItem<GuiProdukt> cleanedChild = cleanTree(child);
+            if (cleanedChild != null) {
+                newItem.getChildren().add(cleanedChild);
+            }
+        }
+        return newItem;
+    }
+
+    public TreeItem<GuiProdukt> cloneTreeItem(TreeItem<GuiProdukt> original) {
+        ProduktbausteinType cloneOriginalValue;
+
+        cloneOriginalValue = new ObjectFactoryFactory().create(((ProduktbausteinType) original.getValue().getProdukt()).getTyp());
+
+        cloneOriginalValue.setId(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getId());
+        cloneOriginalValue.setBezeichnung(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getBezeichnung());
+        cloneOriginalValue.setVerkaufsoffenVon(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getVerkaufsoffenVon());
+        cloneOriginalValue.setVerkaufsoffenBis(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getVerkaufsoffenBis());
+        cloneOriginalValue.getAttribute().addAll(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getAttribute());
+        cloneOriginalValue.getMeldungen().addAll(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getMeldungen());
+        cloneOriginalValue.setMinVorkommen(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getMinVorkommen());
+        cloneOriginalValue.setMaxVorkommen(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getMaxVorkommen());
+        cloneOriginalValue.setTyp(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getTyp());
+        cloneOriginalValue.setRisikoobjektErforderlich(
+                ((ProduktbausteinType) original.getValue().getProdukt()).isRisikoobjektErforderlich());
+        cloneOriginalValue.getVersicherteObjekte().addAll(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getVersicherteObjekte());
+        cloneOriginalValue.setPraemienfaktor(
+                ((ProduktbausteinType) original.getValue().getProdukt()).getPraemienfaktor());
+
+        TreeItem<GuiProdukt> clonedItem = new TreeItem<>(new GuiProdukt(cloneOriginalValue));
+
+        for (TreeItem<GuiProdukt> child : original.getChildren()) {
+            clonedItem.getChildren().add(cloneTreeItem(child));
+        }
+        clonedItem.setExpanded(true);
+
+        clonedItem.getValue().setNotIncluded(original.getValue().isNotIncluded());
+
+        return clonedItem;
+    }
+
+    public TreeItem<GuiProdukt> findTreeItem(ProduktbausteinType item, TreeItem<GuiProdukt> root) {
+        if (((ProduktbausteinType) root.getValue().getProdukt()).getId().equals(item.getId())) {
+            return root;
+        }
+        for (TreeItem<GuiProdukt> child : root.getChildren()) {
+            TreeItem<GuiProdukt> found = findTreeItem(item, child);
+            if (found != null) return found;
+        }
+        return null;
+    }
+
+    public void aprioriProduktToTree(APrioriProduktbausteinType produkt, TreeItem<GuiProdukt> treeItem) throws Exception {
+        if (!produkt.getBausteine().isEmpty()) {
+            for (int i = 0; i < produkt.getBausteine().size(); i++) {
+                TreeItem<GuiProdukt> up = aprioriItemToCalcItem(new TreeItem<>(new GuiProdukt(produkt.getBausteine().get(i))));
+                up.getValue().setNotIncluded(true);
+                up.setExpanded(true);
+                if (!produkt.getBausteine().get(i).getBausteine().isEmpty()) {
+                    aprioriProduktToTree(produkt.getBausteine().get(i), up);
+                }
+                treeItem.getChildren().add(up);
+            }
+        }
+    }
+
+    public void produktToTree(ProduktbausteinType produkt, TreeItem<GuiProdukt> treeItem) throws Exception {
+        if (produkt != null && !produkt.getBausteine().isEmpty()) {
+            for (int i = 0; i < produkt.getBausteine().size(); i++) {
+                TreeItem<GuiProdukt> up = new TreeItem<>(new GuiProdukt(produkt.getBausteine().get(i)));
+                up.setExpanded(true);
+
+                if (!produkt.getBausteine().get(i).getBausteine().isEmpty()) {
+                    produktToTree(produkt.getBausteine().get(i), up);
+                }
+                treeItem.getChildren().add(up);
+                if (!timesItemisIncludedById.containsKey(((ProduktbausteinType) up.getValue().getProdukt()).getId())) {
+                    timesItemisIncludedById.put(((ProduktbausteinType) up.getValue().getProdukt()).getId(), 1);
+                }
+            }
+        }
+    }
+
+    public TreeItem<GuiProdukt> aprioriItemToCalcItem(TreeItem<GuiProdukt> produkt) throws Exception {
+
+        TreeItem<GuiProdukt> ergItem = new TreeItem<>();
+        ProduktbausteinType erg = new ObjectFactoryFactory().create(
+                ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getType());
+
+        if (erg != null) {
+            if (ProduktbausteinType.class.isAssignableFrom(erg.getClass())) {
+                erg.setId(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getId());
+                erg.setBezeichnung(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getName());
+                erg.setVerkaufsoffenVon(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getFrom());
+                erg.setVerkaufsoffenBis(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getTo());
+                erg.getMeldungen().addAll(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getMeldungen());
+                erg.getAttribute().addAll(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getAttribute());
+                erg.setMinVorkommen(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getMinOccurrences());
+                erg.setMaxVorkommen(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getMaxOccurrences());
+                erg.setTyp(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getType());
+                erg.setRisikoobjektErforderlich(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getRisikoobjektType() != null);
+                erg.setPraemienfaktor(
+                        ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getPraemienfaktor());
+
+                for (int i = 0; i < ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getBausteine().size(); i++) {
+                    erg.getBausteine().add((ProduktbausteinType) aprioriItemToCalcItem(
+                            new TreeItem<>(new GuiProdukt(((APrioriProduktbausteinType) produkt.getValue().getProdukt())
+                                    .getBausteine().get(i)))).getValue().getProdukt());
+                }
+
+                for (int i = 0; i < produkt.getChildren().size(); i++) {
+                    ergItem.getChildren().add(aprioriItemToCalcItem(produkt.getChildren().get(i)));
+                }
+            }
+        } else {
+            throw new Exception("Objekt kann nicht erzeugt werden. Unbekannte Klasse "
+                    + ((APrioriProduktbausteinType) produkt.getValue().getProdukt()).getType());
+        }
+        ergItem.setValue(new GuiProdukt(erg));
+        return ergItem;
+    }
+
+    public TreeItem<GuiProdukt> addAprioriToCalc(TreeItem<GuiProdukt> calcItem, TreeItem<GuiProdukt> aprioriItem) {
+        for (TreeItem<GuiProdukt> aprioriChild : aprioriItem.getChildren()) {
+            boolean isInCalc = false;
+            int i = 0;
+            for (TreeItem<GuiProdukt> calcChild : calcItem.getChildren()) {
+                if (((ProduktbausteinType) calcChild.getValue().getProdukt()).getId().equals(
+                        ((ProduktbausteinType) aprioriChild.getValue().getProdukt()).getId())
+                        && !calcChild.getValue().isNotIncluded()) {
+                    isInCalc = true;
+                    if (!aprioriChild.getChildren().isEmpty()) {
+                        addAprioriToCalc(calcChild, aprioriChild);
+                    }
+                }
+                i++;
+            }
+            if (!isInCalc) {
+                TreeItem<GuiProdukt> missingCalcItem = cloneTreeItem(aprioriChild);
+                calcItem.getChildren().add(missingCalcItem);
+            }
+        }
+        return calcItem;
+    }
+
+    public TreeItem<GuiProdukt> sortTree(TreeItem<GuiProdukt> parent) {
+        FXCollections.sort(parent.getChildren(), Comparator.comparing(
+                item -> ((ProduktbausteinType)item.getValue().getProdukt()).getBezeichnung()
+        ));
+
+        for (TreeItem<GuiProdukt> child : parent.getChildren()) {
+            sortTree(child);
+        }
+        return parent;
+    }
+}

client-lib/src/main/java/com/kapdion/pisano/Main.java

@@ -1,17 +0,0 @@
-package com.kapdion.pisano;
-
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
-public class Main {
-    public static void main(String[] args) {
-        //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-        // to see how IntelliJ IDEA suggests fixing it.
-        System.out.printf("Hello and welcome!");
-
-        for (int i = 1; i <= 5; i++) {
-            //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-            // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-            System.out.println("i = " + i);
-        }
-    }
-}

client-lib/src/main/resources/def/external/oasis-200401-wss-wssecurity-utility-1.0.xsd

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+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 2002-2004. 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 does 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 targetNamespace="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+
+
+
+xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" 
+elementFormDefault="qualified" attributeFormDefault="unqualified" version="0.1">
+	<!-- // Fault Codes /////////////////////////////////////////// -->
+	<xsd:simpleType name="tTimestampFault">
+		<xsd:annotation>
+			<xsd:documentation>
+This type defines the fault code value for Timestamp message expiration.
+          </xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:QName">
+			<xsd:enumeration value="wsu:MessageExpired"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- // Global attributes //////////////////////////////////// -->
+	<xsd:attribute name="Id" type="xsd:ID">
+		<xsd:annotation>
+			<xsd:documentation>
+This global attribute supports annotating arbitrary elements with an ID.
+          </xsd:documentation>
+		</xsd:annotation>
+	</xsd:attribute>
+	<xsd:attributeGroup name="commonAtts">
+		<xsd:annotation>
+			<xsd:documentation>
+Convenience attribute group used to simplify this schema.
+          </xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute ref="wsu:Id" use="optional"/>
+		<xsd:anyAttribute namespace="##other" processContents="lax"/>
+	</xsd:attributeGroup>
+	<!-- // Utility types //////////////////////////////////////// -->
+	<xsd:complexType name="AttributedDateTime">
+		<xsd:annotation>
+			<xsd:documentation>
+This type is for elements whose [children] is a psuedo-dateTime and can have arbitrary attributes. 
+      </xsd:documentation>
+		</xsd:annotation>
+		<xsd:simpleContent>
+			<xsd:extension base="xsd:string">
+				<xsd:attributeGroup ref="wsu:commonAtts"/>
+			</xsd:extension>
+		</xsd:simpleContent>
+	</xsd:complexType>
+	<xsd:complexType name="AttributedURI">
+		<xsd:annotation>
+			<xsd:documentation>
+This type is for elements whose [children] is an anyURI and can have arbitrary attributes.
+      </xsd:documentation>
+		</xsd:annotation>
+		<xsd:simpleContent>
+			<xsd:extension base="xsd:anyURI">
+				<xsd:attributeGroup ref="wsu:commonAtts"/>
+			</xsd:extension>
+		</xsd:simpleContent>
+	</xsd:complexType>
+	<!-- // Timestamp header components /////////////////////////// -->
+	<xsd:complexType name="TimestampType">
+		<xsd:annotation>
+			<xsd:documentation>
+This complex type ties together the timestamp related elements into a composite type.
+            </xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element ref="wsu:Created" minOccurs="0"/>
+			<xsd:element ref="wsu:Expires" minOccurs="0"/>
+			<xsd:choice minOccurs="0" maxOccurs="unbounded">
+				<xsd:any namespace="##other" processContents="lax"/>
+			</xsd:choice>
+		</xsd:sequence>
+		<xsd:attributeGroup ref="wsu:commonAtts"/>
+	</xsd:complexType>
+	<xsd:element name="Timestamp" type="wsu:TimestampType">
+		<xsd:annotation>
+			<xsd:documentation>
+This element allows Timestamps to be applied anywhere element wildcards are present,
+including as a SOAP header.
+            </xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<!-- global element decls to allow individual elements to appear anywhere -->
+	<xsd:element name="Expires" type="wsu:AttributedDateTime">
+		<xsd:annotation>
+			<xsd:documentation>
+This element allows an expiration time to be applied anywhere element wildcards are present.
+            </xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="Created" type="wsu:AttributedDateTime">
+		<xsd:annotation>
+			<xsd:documentation>
+This element allows a creation time to be applied anywhere element wildcards are present.
+            </xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/external/ws-2004-09-policy-ws-policy.xsd

@@ -0,0 +1,118 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+(c) 2001-2006 BEA Systems Inc., International Business Machines Corporation, Microsoft Corporation, Inc., SAP AG, Sonic Software, and VeriSign, Inc. All rights reserved.
+
+Permission to copy and display the WS-Policy Specification (the "Specification", which includes WSDL and schema documents), in any medium without fee or royalty is hereby granted, provided that you include the following on ALL copies of the WS-Policy Specification, that you make:
+
+1.	A link or URL to the WS-Policy Specification at one of the Authors' websites
+2.	The copyright notice as shown in the WS-Policy Specification.
+
+BEA Systems, IBM, Microsoft, SAP, Sonic Software, and VeriSign (collectively, the "Authors") each agree to grant you a license, under royalty-free and otherwise reasonable, non-discriminatory terms and conditions, to their respective essential patent claims that they deem necessary to implement the WS-Policy Specification.
+
+THE WS-POLICY SPECIFICATION IS PROVIDED "AS IS," AND THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE WS-POLICY SPECIFICATION ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
+
+THE AUTHORS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO ANY USE OR DISTRIBUTION OF THE WS-POLICY SPECIFICATION.
+
+The name and trademarks of the Authors may NOT be used in any manner, including advertising or publicity pertaining to the WS-Policy Specification or its contents without specific, written prior permission. Title to copyright in the WS-Policy Specification will at all times remain with the Authors.
+
+No other rights are granted by implication, estoppel or otherwise.
+-->
+<xs:schema 
+	  targetNamespace="http://schemas.xmlsoap.org/ws/2004/09/policy"
+	  xmlns:tns="http://schemas.xmlsoap.org/ws/2004/09/policy"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+    xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+    xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+    elementFormDefault="qualified"
+    blockDefault="#all" >
+
+  <xs:import 
+		namespace="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+		schemaLocation="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" />
+
+  <xs:import 
+		namespace="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+		schemaLocation="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" />
+
+  <!-- ////////// WS-Policy ////////// -->
+
+  <xs:element name="Policy" >
+    <xs:complexType>
+      <xs:complexContent>
+        <xs:extension base="tns:OperatorContentType" >
+          <xs:attribute name="Name" type="xs:anyURI" />
+          <xs:attribute ref="wsu:Id" />
+          <xs:anyAttribute namespace="##any" processContents="lax" />
+        </xs:extension>
+      </xs:complexContent>
+    </xs:complexType>
+  </xs:element>
+  <xs:element name="All" type="tns:OperatorContentType" />
+  <xs:element name="ExactlyOne" type="tns:OperatorContentType" />
+
+  <xs:complexType name="OperatorContentType" >
+    <xs:sequence>
+      <xs:choice minOccurs="0" maxOccurs="unbounded" >
+        <xs:element ref="tns:Policy" />
+        <xs:element ref="tns:All" />
+        <xs:element ref="tns:ExactlyOne" />
+        <xs:element ref="tns:PolicyReference" />
+        <xs:any namespace="##other" processContents="lax" />
+      </xs:choice>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="PolicyReference" >
+    <xs:complexType>
+      <xs:attribute name="URI" type="xs:anyURI" use="required" />
+      <xs:attribute name="Digest" type="xs:base64Binary" />
+      <xs:attribute name="DigestAlgorithm" 
+                    type="xs:anyURI" 
+                    default="http://schemas.xmlsoap.org/ws/2004/09/policy/Sha1Exc"
+                    />
+      <xs:anyAttribute namespace="##any" processContents="lax" />
+    </xs:complexType>
+  </xs:element>
+
+  <xs:attribute name="Optional" type="xs:boolean" default="false" />
+
+  <!-- ////////// WS-PolicyAttachment ////////// -->
+
+  <xs:attribute name="PolicyURIs" >
+    <xs:simpleType>
+      <xs:list itemType="xs:anyURI" />
+    </xs:simpleType>
+  </xs:attribute>
+
+  <xs:element name="PolicyAttachment" >
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element ref="tns:AppliesTo" />
+        <xs:choice maxOccurs="unbounded" >
+          <xs:element ref="tns:Policy" />
+          <xs:element ref="tns:PolicyReference" />
+        </xs:choice>
+        <!-- omitted only because it causes the content model to be non-determistic
+        <xs:element ref="wsse:Security" minOccurs="0" />
+-->
+        <xs:any namespace="##other"
+						processContents="lax"
+						minOccurs="0"
+						maxOccurs="unbounded" />
+      </xs:sequence>
+      <xs:anyAttribute namespace="##any" processContents="lax" />
+    </xs:complexType>
+  </xs:element>
+
+  <xs:element name="AppliesTo" >
+    <xs:complexType>
+      <xs:sequence>
+        <xs:any namespace="##any"
+						processContents="lax"
+						maxOccurs="unbounded" />
+      </xs:sequence>
+      <xs:anyAttribute namespace="##any" processContents="lax" />
+    </xs:complexType>
+  </xs:element>
+
+</xs:schema>

client-lib/src/main/resources/def/external/ws-2005-07-securitypolicy-ws-securitypolicy.xsd

@@ -0,0 +1,979 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<xs:schema
+	targetNamespace="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy"
+    xmlns:tns="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy"
+	xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing"
+	xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+	elementFormDefault="qualified"
+	blockDefault="#all" >
+
+	<xs:import namespace="http://schemas.xmlsoap.org/ws/2004/08/addressing" 
+		schemaLocation="http://schemas.xmlsoap.org/ws/2004/08/addressing" />
+
+	<xs:import namespace="http://schemas.xmlsoap.org/ws/2004/09/policy" 
+		schemaLocation="http://schemas.xmlsoap.org/ws/2004/09/policy/ws-policy.xsd" />
+
+	<!--
+	5. Protection Assertions
+	-->
+	<xs:element name="SignedParts" type="tns:SePartsType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				5.1.1 SignedParts Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="EncryptedParts" type="tns:SePartsType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				5.2.1 EncryptedParts Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="SePartsType">
+		<xs:sequence>
+			<xs:element name="Body" type="tns:EmptyType" minOccurs="0" />
+			<xs:element name="Header" type="tns:HeaderType" minOccurs="0" maxOccurs="unbounded" />
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax"/>
+		</xs:sequence>
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+	<xs:complexType name="EmptyType" />
+	<xs:complexType name="HeaderType" >
+		<xs:attribute name="Name" type="xs:QName" use="optional" />
+		<xs:attribute name="Namespace" type="xs:anyURI" use="required" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<xs:element name="SignedElements" type="tns:SerElementsType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en" >
+				5.1.2 SignedElements Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="EncryptedElements" type="tns:SerElementsType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				5.2.2 EncryptedElements Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequiredElements" type="tns:SerElementsType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en" >
+				5.3.1 RequiredElements Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="SerElementsType">
+		<xs:sequence>
+            <xs:element name="XPath" type="xs:string" minOccurs="1" maxOccurs="unbounded" />
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax"/>
+		</xs:sequence>
+		<xs:attribute name="XPathVersion" type="xs:anyURI" use="optional" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<!--
+	6. Token Assertions
+	-->
+	<xs:attribute name="IncludeToken" type="tns:IncludeTokenOpenType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.1 Token Inclusion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:attribute>
+	<xs:simpleType name="IncludeTokenOpenType">
+		<xs:union memberTypes="tns:IncludeTokenType xs:anyURI" />
+	</xs:simpleType>
+	<xs:simpleType name="IncludeTokenType">
+		<xs:restriction base="xs:anyURI" >
+			<xs:enumeration value="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never" />
+			<xs:enumeration value="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Once" />
+			<xs:enumeration value="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient" />
+			<xs:enumeration value="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Always" />
+		</xs:restriction>
+	</xs:simpleType>
+
+	<xs:element name="UsernameToken" type="tns:TokenAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en" >
+				6.3.1 UsernameToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="TokenAssertionType">
+		<xs:sequence>
+			<!--
+			*** Accurate content model is nondeterministic ***
+			<xs:element ref="wsp:Policy" minOccurs="0" />
+			-->
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax"/>
+		</xs:sequence>
+		<xs:attribute ref="tns:IncludeToken" use="optional" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<xs:element name="WssUsernameToken10" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.1 UsernameToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssUsernameToken11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.1 UsernameToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="QNameAssertionType">
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<xs:element name="IssuedToken" type="tns:IssuedTokenType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.2 IssuedToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="IssuedTokenType">
+		<xs:sequence>
+			<xs:element name="Issuer" type="wsa:EndpointReferenceType" minOccurs="0" />
+			<xs:element name="RequestSecurityTokenTemplate" type="tns:RequestSecurityTokenTemplateType" />
+			<!--
+			*** Accurate content model is nondeterministic ***
+			<xs:element ref="wsp:Policy" minOccurs="0" />
+			-->
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" />			
+		</xs:sequence>
+		<xs:attribute ref="tns:IncludeToken" use="optional" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+	<xs:complexType name="RequestSecurityTokenTemplateType">
+		<xs:sequence>
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" />
+		</xs:sequence>
+		<xs:attribute name="TrustVersion" type="xs:anyURI" use="optional" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<xs:element name="RequireDerivedKeys" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.2 IssuedToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireExternalReference" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.2 IssuedToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireInternalReference" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.2 IssuedToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="X509Token" type="tns:TokenAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="RequireKeyIdentifierReference" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireIssuerSerialReference" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireEmbeddedTokenReference" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireThumbprintReference" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509V1Token10" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509V3Token10" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509Pkcs7Token10" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509PkiPathV1Token10" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509V1Token11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509V3Token11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509Pkcs7Token11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssX509PkiPathV1Token11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.3 X509Token Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="KerberosToken" type="tns:TokenAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.4 KerberosToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- RequireDerivedKeys defined above. -->
+	<!-- RequireKeyIdentifierReference defined above. -->
+
+	<xs:element name="WssKerberosV5ApReqToken11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.4 KerberosToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssGssKerberosV5ApReqToken11" type="tns:QNameAssertionType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.4 KerberosToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="SpnegoContextToken" type="tns:SpnegoContextTokenType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en" >
+				6.3.5 SpnegoContextToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="SpnegoContextTokenType">
+		<xs:sequence>
+			<xs:element name="Issuer" type="wsa:EndpointReferenceType" minOccurs="0" />
+			<!--
+			*** Accurate content model is nondeterministic ***
+			<xs:element ref="wsp:Policy" minOccurs="0" />
+			-->
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" />
+		</xs:sequence>
+		<xs:attribute ref="tns:IncludeToken" use="optional" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+	<!-- RequireDerivedKeys defined above. -->
+
+	<xs:element name="SecurityContextToken" type="tns:TokenAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.6 SecurityContextToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- RequireDerivedKeys defined above. -->
+
+	<xs:element name="RequireExternalUriReference" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.6 SecurityContextToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="SC10SecurityContextToken" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.6 SecurityContextToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="SecureConversationToken" type="tns:SecureConversationTokenType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.7 SecureConversationToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="SecureConversationTokenType">
+		<xs:sequence>
+			<xs:element name="Issuer" type="wsa:EndpointReferenceType" minOccurs="0" />
+			<!--
+			*** Accurate content model is nondeterministic ***
+			<xs:element ref="wsp:Policy" minOccurs="0" />
+			-->
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" />
+		</xs:sequence>
+		<xs:attribute ref="tns:IncludeToken" use="optional" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+	<!-- RequireDerivedKeys defined above. -->
+	<!-- RequireExternalUriReference defined above. -->
+	<!-- SC10SecurityContextToken defined above. -->
+
+	<xs:element name="BootstrapPolicy" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.7 SecureConversationToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="SamlToken" type="tns:TokenAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en" >
+				6.3.8 SamlToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- RequireDerivedKeys defined above. -->
+	<!-- RequireKeyIdentifierReference defined above. -->
+
+	<xs:element name="WssSamlV10Token10" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.8 SamlToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssSamlV11Token10" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.8 SamlToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssSamlV10Token11" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.8 SamlToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssSamlV11Token11" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.8 SamlToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssSamlV20Token11" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.8 SamlToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="RelToken" type="tns:TokenAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.9 RelToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- RequireDerivedKeys defined above. -->
+	<!-- RequireKeyIdentifierReference defined above. -->
+
+	<xs:element name="WssRelV10Token10" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.9 RelToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssRelV20Token10" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.9 RelToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssRelV10Token11" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.9 RelToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="WssRelV20Token11" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.9 RelToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="HttpsToken" type="tns:HttpsTokenType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				6.3.10 HttpsToken Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="HttpsTokenType">
+		<xs:sequence>
+			<!--
+			*** Accurate content model is nondeterministic ***
+			<xs:element ref="wsp:Policy" minOccurs="0" />
+			-->
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax"/>
+		</xs:sequence>
+		<xs:attribute name="RequireClientCertificate" type="xs:boolean" use="required" />
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<!--
+	8. Security Binding Assertions
+	-->
+	<xs:element name="AlgorithmSuite" type="tns:NestedPolicyType" >
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:complexType name="NestedPolicyType">
+		<xs:sequence>
+			<xs:element ref="wsp:Policy" />
+			<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax"/>
+		</xs:sequence>
+		<xs:anyAttribute namespace="##any" processContents="lax" />
+	</xs:complexType>
+
+	<xs:element name="Basic256" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic192" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic128" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="TripleDes" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic256Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic192Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic128Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="TripleDesRsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic256Sha256" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic192Sha256" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic128Sha256" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="TripleDesSha256" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic256Sha256Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic192Sha256Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Basic128Sha256Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="TripleDesSha256Rsa15" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="InclusiveC14N" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="SOAPNormalization10" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="STRTransform10" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="XPathFilter20" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.1 AlgorithmSuite Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="Layout" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.2 Layout Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="Strict" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.2 Layout Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="Lax" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.2 Layout Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="LaxTsFirst" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.2 Layout Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="LaxTsLast" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.2 Layout Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="TransportBinding" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.3 TransportBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="TransportToken" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.3 TransportBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- Layout defined above. -->
+
+	<xs:element name="IncludeTimestamp" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.3 TransportBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- RequireDerivedKeys defined above. -->
+
+	<xs:element name="SymmetricBinding" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="EncryptionToken" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="SignatureToken" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="ProtectionToken" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- Layout defined above. -->
+	<!-- IncludeTimestamp defined above. -->
+
+	<xs:element name="EncryptBeforeSigning" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="EncryptSignature" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="ProtectTokens" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- RequireDerivedKeys defined above. -->
+	<xs:element name="OnlySignEntireHeadersAndBody" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.4 SymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="AsymmetricBinding" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.5 AsymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="InitiatorToken" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.5 AsymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="RecipientToken" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				8.5 AsymmetricBinding Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- Layout defined above. -->
+	<!-- IncludeTimestamp defined above. -->
+	<!-- EncryptBeforeSigning defined above. -->
+	<!-- EncryptSignature defined above. -->
+	<!-- ProtectTokens defined above. -->
+	<!-- RequireDerivedKeys defined above. -->
+	<!-- OnlySignEntireHeadersAndBody defined above. -->
+
+	<!--
+	9. Supporting Tokens
+	-->
+	<xs:element name="SupportingTokens" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				9.1 SupportingTokens Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- SignedParts defined above. -->
+	<!-- SignedElements defined above. -->
+	<!-- EncryptedParts defined above. -->
+	<!-- EncryptedElements defined above. -->
+
+	<xs:element name="SignedSupportingTokens" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				9.2 SignedSupportingTokens Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- SignedParts defined above. -->
+	<!-- SignedElements defined above. -->
+	<!-- EncryptedParts defined above. -->
+	<!-- EncryptedElements defined above. -->
+
+	<xs:element name="EndorsingSupportingTokens" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				9.3 EndorsingSupportingTokens Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- SignedParts defined above. -->
+	<!-- SignedElements defined above. -->
+	<!-- EncryptedParts defined above. -->
+	<!-- EncryptedElements defined above. -->
+
+	<xs:element name="SignedEndorsingSupportingTokens" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				9.4 SignedEndorsingSupportingTokens Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- AlgorithmSuite defined above. -->
+	<!-- SignedParts defined above. -->
+	<!-- SignedElements defined above. -->
+	<!-- EncryptedParts defined above. -->
+	<!-- EncryptedElements defined above. -->
+
+	<!--
+	10. WSS: SOAP Message Security Options
+	-->
+	<xs:element name="Wss10" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.1 Wss10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="MustSupportRefKeyIdentifier" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.1 Wss10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="MustSupportRefIssuerSerial" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.1 Wss10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="MustSupportRefExternalURI" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.1 Wss10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="MustSupportRefEmbeddedToken" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.1 Wss10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="Wss11" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.2 Wss11 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<!-- MustSupportRefKeyIdentifier defined above. -->
+	<!-- MustSupportRefIssuerSerial defined above. -->
+	<!-- MustSupportRefExternalURI defined above. -->
+	<!-- MustSupportRefEmbeddedToken defined above. -->
+
+	<xs:element name="MustSupportRefThumbprint" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.2 Wss11 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="MustSupportRefEncryptedKey" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.2 Wss11 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireSignatureConfirmation" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				10.2 Wss11 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<!--
+	11. WS-Trust Options
+	-->
+	<xs:element name="Trust10" type="tns:NestedPolicyType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				11.1 Trust10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+	<xs:element name="MustSupportClientChallenge" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				11.1 Trust10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="MustSupportServerChallenge" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				11.1 Trust10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireClientEntropy" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				11.1 Trust10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="RequireServerEntropy" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				11.1 Trust10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+	<xs:element name="MustSupportIssuedTokens" type="tns:QNameAssertionType">
+		<xs:annotation>
+			<xs:documentation xml:lang="en">
+				11.1 Trust10 Assertion
+			</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+
+</xs:schema>

client-lib/src/main/resources/def/external/ws-policy.xsd

@@ -0,0 +1,141 @@
+<?xml version='1.0' encoding='utf-8' ?>
+<!--
+
+    W3C XML Schema defined in the Web Services Policy 1.5
+    Framework specification
+
+    http://www.w3.org/TR/ws-policy-framework
+
+   Copyright © 2006 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
+
+   $Id: ws-policy.xsd,v 1.2 2007/02/14 16:38:37 fsasaki Exp $
+-->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+	xmlns:tns="http://www.w3.org/ns/ws-policy"
+	xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+	xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	targetNamespace="http://www.w3.org/ns/ws-policy" blockDefault="#all"
+	elementFormDefault="qualified">
+	
+  <xs:import 
+      namespace="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+      schemaLocation="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" />
+
+  <xs:import 
+      namespace="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+      schemaLocation="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" />
+  
+  <xs:import
+      namespace="http://www.w3.org/XML/1998/namespace"
+      schemaLocation="http://www.w3.org/2001/xml.xsd" />
+  
+	<!-- Constructs from the Web Services Policy 1.5 Framework -->
+
+  <xs:element name="Policy" >
+    <xs:complexType>
+
+      <xs:complexContent>
+        <xs:extension base="tns:OperatorContentType" >
+          <xs:attribute name="Name" type="xs:anyURI" />
+          <xs:anyAttribute namespace="##any" processContents="lax" />
+        </xs:extension>
+      </xs:complexContent>
+    </xs:complexType>
+  </xs:element>
+
+  <xs:element name="All" type="tns:OperatorContentType" />
+  <xs:element name="ExactlyOne" type="tns:OperatorContentType" />
+
+  <xs:complexType name="OperatorContentType" >
+    <xs:sequence>
+      <xs:choice minOccurs="0" maxOccurs="unbounded" >
+        <xs:element ref="tns:Policy" />
+        <xs:element ref="tns:All" />
+        <xs:element ref="tns:ExactlyOne" />
+
+        <xs:element ref="tns:PolicyReference" />
+        <xs:any namespace="##other" processContents="lax" />
+      </xs:choice>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="PolicyReference" >
+    <xs:complexType>
+      <xs:sequence>
+        <xs:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+      </xs:sequence>
+      <xs:attribute name="URI" type="xs:anyURI" use="required" />
+
+      <xs:attribute name="Digest" type="xs:base64Binary" />
+      <xs:attribute name="DigestAlgorithm" 
+                    type="xs:anyURI" 
+                    default="http://www.w3.org/ns/ws-policy/Sha1Exc"
+                    />
+      <xs:anyAttribute namespace="##any" processContents="lax" />
+    </xs:complexType>
+  </xs:element>
+
+  <xs:attribute name="Optional" type="xs:boolean" default="false" />
+  <xs:attribute name="Ignorable" type="xs:boolean" default="false" />
+  	
+	<!-- Constructs from the Web Services Policy 1.5 Attachment -->
+
+  <xs:attribute name="PolicyURIs" >
+    <xs:simpleType>
+      <xs:list itemType="xs:anyURI" />
+    </xs:simpleType>
+  </xs:attribute>
+
+  <xs:element name="PolicyAttachment" >
+    <xs:complexType>
+      <xs:sequence>
+
+        <xs:element ref="tns:AppliesTo" />
+        <xs:choice maxOccurs="unbounded" >
+          <xs:element ref="tns:Policy" />
+          <xs:element ref="tns:PolicyReference" />
+        </xs:choice>
+        <!-- omitted only because it causes the content model to be non-determistic
+        <xs:element ref="wsse:Security" minOccurs="0" />
+-->
+        <xs:any namespace="##other"
+		processContents="lax"
+		minOccurs="0"
+		maxOccurs="unbounded" />
+      </xs:sequence>
+      <xs:anyAttribute namespace="##any" processContents="lax" />
+
+    </xs:complexType>
+  </xs:element>
+
+  <xs:element name="AppliesTo" >
+    <xs:complexType>
+      <xs:sequence>
+        <xs:any namespace="##any"
+		processContents="lax"
+		maxOccurs="unbounded" />
+      </xs:sequence>
+      <xs:anyAttribute namespace="##any" processContents="lax" />
+
+    </xs:complexType>
+  </xs:element>
+
+  <xs:element name="URI">
+    <xs:complexType>
+      <xs:simpleContent>
+        <xs:extension base="xs:anyURI">
+          <xs:anyAttribute namespace="##any" processContents="lax" />
+        </xs:extension>
+      </xs:simpleContent>
+    </xs:complexType>
+  </xs:element>
+  	
+</xs:schema>

client-lib/src/main/resources/def/r1_10_0/omds3ServiceTypes.xsd

@@ -0,0 +1,688 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3ServiceTypes-1-1-0" xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:omds3ServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<!-- Beziehe Action Link -->
+	<xsd:element name="loginRequest" type="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt für den Actionlink</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ des Request-Objekts fuer den allgemeinen Portaleinstieg</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="loginResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Der Actionlink z.B. in das Maklerportal mit einem Token, der die Verbindung zur Session herstellt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<!-- Beziehe User-Daten -->
+	<xsd:element name="getUserDataRequest" type="UserDataRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt fuer den Zugriff auf die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die VUNr des angefragten Unternehmens. Dies ermöglicht ggf. mehrere VUs über eine technische Lösung zu servicieren. Verwendet den Typ VUNr aus OMDS-Datensatz.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getUserDataResponse" type="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Das Ergebnisobjekt fuer die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Type mit Benutzerinformationen. Das Element 'address' ist mit Version 1.1.0 entfallen, da diese Informationen auch im Element 'person' übermittelt werden können
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="userid">
+				<xsd:annotation>
+					<xsd:documentation>BenutzerId</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="availableServices">
+				<xsd:annotation>
+					<xsd:documentation>Liste der für diesen User unterstützen Services</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="service" type="xsd:string" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Die ServiceId des jeweiligen Webservice als String</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="person" type="omds:PERSON_Type">
+				<xsd:annotation>
+					<xsd:documentation>Ist vom Typ PERSON_Type aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste verfuegbarer OMDS-Datensaetze -->
+	<xsd:element name="getOMDSPackageListRequest" type="OMDSPackageListRequest">
+		<xsd:annotation>
+			<xsd:documentation>Inputobjekt zum Beziehen einer Liste verfuegbarer OMDS-Datensaetze</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>die VUNr aus OMDS als optionaler Filterparameter</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>von inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>bis inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageListResponse" type="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabeobjekt für eine Liste von OMDS-Datensätzen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine Liste von OMDS-Datensaetzen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence minOccurs="0">
+			<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" minOccurs="0" maxOccurs="unbounded"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe einzelnen OMDS-Datensatz -->
+	<xsd:element name="getOMDSPackageRequest" type="OMDSPackageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Requestobjekt fuer die Abholung eines oder mehrerer OMDS-Datensatz-Packages</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageId" type="xsd:string" nillable="false" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Datensatzes unter welcher er ueber Webservices referenziert werden kann. Es handelt sich nicht um eine Id aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageResponse" type="OMDSPackageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Gibt die Liste der angeforderten OMDS-Packages zurück oder entsprechende fachliche Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageResponse">
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackage" type="RequestedOMDSPackage" nillable="false" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste der angeforderten Pakete</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="RequestedOMDSPackage">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer ein OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackageId" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Die angefragte Id des OMDS-Datenpakets, wobei dies kein Schlüssel aus dem Paket ist. </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="omdsPackage" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Nur enthalten, wenn es das angeforderte Paket tatsächlich gibt und der User darauf berechtigt ist.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" nillable="false">
+							<xsd:annotation>
+								<xsd:documentation>Meta-Informationen zu diesem Paket</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="content" type="xsd:base64Binary" xmime:expectedContentTypes="application/zip">
+							<xsd:annotation>
+								<xsd:documentation>Gezippte OMDS-Daten als base64Binary oder mit Binary mit MTOM</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="OMDSPackageInfoType">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die wesentlichen Informationen zu einem OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="MaklerID" type="cst:MaklerID_Type" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Entspricht der MaklerID in OMDS 2.x. Die MaklerID (in Version 1.0.0 noch AgentID) ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für die jeweilige VU oder den jeweiligen Dienstleister, bei dem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die agentID mit der Vermittlernummer "Vermnr" (in Version 1.0.0 noch agentNumber) zusammenfällt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des OMDS Pakets und Angaben zu ihrer Verwendbarkeit, wobei hier kein Schlüssel aus einem OMDS Paket selbst gemeint ist, sondern eine eigenständige Id, die das Abrufen des OMDS-Pakets ermöglicht.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="timeStamp" type="omds:Datum-Zeit" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Zeitstempel der Erstellung entsprechend dem Attribut PaketZpktErstell mit OMDS Datum-Zeit als Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageSize" type="xsd:int" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Groesse der Datei in Byte, de facto beschränkt auf max. ca. 2 GB da vom Typ int</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageExtent" type="omds:PaketUmfCd_Type">
+				<xsd:annotation>
+					<xsd:documentation>entspricht dem der Paketumfang wie er in OMDS 2.x im Typ PaketUmfCd_Type definiert ist: D = Differenz, G = Gesamtbestand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageContentCode" type="omds:PaketInhCd_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste von OMDS 2.x Elementen des Typs PaketInhCd_Type, die den Inhalt des Datenpakets beschreiben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste vertragsbezogener Dokumente -->
+	<xsd:element name="getArcImageInfosRequest" type="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfrage Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfragetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>die Polizzennummer als OMDS Polizzennr-Typ.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyType" type="omds:VtgProdCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für Polizzen eines bestimmten Typs. Das Attribut ist vom Typ VtgProdCd_Type des OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyPartnerRole" type="PolicyPartnerRole" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für bestimmte Partner in einer bestimmten Rolle</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf bestimmte Dokumententypen. Es gibt 15 definierte vertragsbezogene Dokumententypen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageInfosResponse" type="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabe Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Informationen zu Dokumenten, wenn vorhanden</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageRequest" type="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requesttyp zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArcImageId">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Dokuments vom Typ String</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<!--<xsd:element name="policy" type="Policy"/>-->
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageResponse" type="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responsetyp zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ArcContent" type="ArcContent" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Das Dokument und seine Meta-Informationen, wenn ein Dokument vorhanden war</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="PolicyPartnerRole">
+		<xsd:annotation>
+			<xsd:documentation>Partnerrollen in einer Polizze: Versicherungsnehmer, Versicherte Person</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS-Personennr (String mit 1-26 Zeichen) </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="partnerRole" type="cst:PartnerRoleType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Partnerrollen im Vertrag als PartnerRoleType: String mit 2 Zeichen: VN, VP</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcImageInfo">
+		<xsd:annotation>
+			<xsd:documentation>Information zu einem einzelnen Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Dokuments und Details zur Verwendung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="name" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Der Name des Dokuments als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType">
+				<xsd:annotation>
+					<xsd:documentation>Der inhaltliche Typ des Dokuments, z.B. "Polizze" oder "Finanzamtsbestätigung" als Integer-Code</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentType" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mime-Type des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentLength" type="xsd:long" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Größe des Dokuments in Byte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="date" type="xsd:date">
+				<xsd:annotation>
+					<xsd:documentation>Erstellungsdatum des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="docReference" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Verweis auf weitere Dokumente, die inhaltlich zu diesem Dokument gehören, z.B. AVB zu einer Polizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcContent">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument und das Dokument base64encoded</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Meta-Informationen zum Dokument (Deprecated, die Daten sollten dem Aufrufer schon bekannt sein)</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcImage" type="xsd:base64Binary" xmime:expectedContentTypes="application/octet-stream">
+				<xsd:annotation>
+					<xsd:documentation>Das eigentliche Dokument als base64-Binary</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe Deep-Links -->
+	<xsd:element name="getDeepLinkClaimRequest" type="DeepLinkClaimRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Schaden Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkClaimRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="claimNumber" type="omds:Schadennr">
+				<xsd:annotation>
+					<xsd:documentation>Schadennummer vom Typ OMDS Schadennr</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkClaimResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt Deep-Link Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPartnerRequest" type="DeepLinkPartnerRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPartnerRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS Personennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPartnerResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkOfferRequest" type="DeepLinkOfferRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot/ Antrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkOfferRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="offerNumber" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer der Berechnung, des Angebots oder des Antrags.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+
+	<xsd:simpleType name="Geschaeftsvorfall">
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Neuantrag"/>
+			<xsd:enumeration value="Aenderungsantrag"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:element name="getDeepLinkOfferResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot / Antrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPolicyRequest" type="DeepLinkPolicyRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPolicyRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer des Vertrags als OMDS Polizzennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPolicyResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkBusinessObjectResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Deep-Link auf Geschäftsobjekte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="withoutFrame" type="xsd:boolean">
+		<xsd:annotation>
+			<xsd:documentation>Soll ein Frame angezeigt werden oder nicht</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="httpActionLink" type="HttpActionLinkType"/>
+	<xsd:complexType name="HttpActionLinkType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen Deep-Link</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="url">
+				<xsd:annotation>
+					<xsd:documentation>String mit max. 1024 Zeichen</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="type">
+				<xsd:annotation>
+					<xsd:documentation>Code für Art der URL, z.B. Verträge, Dokumente, Schäden, Schadenmeldung als int-Type.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:int">
+						<xsd:enumeration value="1">
+							<xsd:annotation>
+								<xsd:documentation>Einstiegsseite</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="2">
+							<xsd:annotation>
+								<xsd:documentation>Suche Partner</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="3">
+							<xsd:annotation>
+								<xsd:documentation>Suche Vertrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="4">
+							<xsd:annotation>
+								<xsd:documentation>Suche Schaden</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="5">
+							<xsd:annotation>
+								<xsd:documentation>Suche Angebot/Antrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="6">
+							<xsd:annotation>
+								<xsd:documentation>Schadenübersicht</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden, keine Doublette zu Nr 12, da hier Übersicht über einzelnen Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="7">
+							<xsd:annotation>
+								<xsd:documentation>Dokumente</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="8">
+							<xsd:annotation>
+								<xsd:documentation>Anfrage</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="9">
+							<xsd:annotation>
+								<xsd:documentation>Stammdaten</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="10">
+							<xsd:annotation>
+								<xsd:documentation>Bearbeiten</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="11">
+							<xsd:annotation>
+								<xsd:documentation>Verträge</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="12">
+							<xsd:annotation>
+								<xsd:documentation>Schäden</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, Keine Doublette zu Nr 6 da hier eine Liste von Schäden zu einem gegebenen Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="13">
+							<xsd:annotation>
+								<xsd:documentation>Angebote</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner, keine Doublette zu Nr 14 Angebots-/ Antragsübersicht, da hier nur Angebote des Partners -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="14">
+							<xsd:annotation>
+								<xsd:documentation>Angebots-/ Antragsübersicht</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, keine Doublette zu Nr 13, da hier Übersichtsseite über alle Angebote/ Anträge des Service-Konsumenten -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="15">
+							<xsd:annotation>
+								<xsd:documentation>Inkassostand</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="16">
+							<xsd:annotation>
+								<xsd:documentation>Angebot</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="17">
+							<xsd:annotation>
+								<xsd:documentation>Schadenmeldung</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="18">
+							<xsd:annotation>
+								<xsd:documentation>Mahnungen</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="validUntil" type="xsd:dateTime" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ablaufzeitpunkt der Action-Links. Wenn Actionslinks vorhanden sind, dieses Element jedoch nicht oder mit dem Wert "null", so sind die ActionLinks zeitlich unbeschränkt gültig. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="DeepLinkBusinessObjectResponse">
+		<xsd:sequence>
+			<xsd:element name="httpActionLink" type="HttpActionLinkType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Linkbeschreibung vom Typ LinkType</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,507 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:element name="AddDocToBusinessCaseRequest" type="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts, um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type"/>
+			<xsd:element name="Dokument" type="cst:Upload_Dokument_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="AddDocToBusinessCaseResponse" type="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice maxOccurs="unbounded">
+			<xsd:element name="DocRef" type="cst:DokumentenReferenz_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsRequest" type="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Anzahl von Dokumenten zu einem fachlichen Objekt zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ enthält die Elemente fuer die Anfrage nach Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type">
+				<xsd:annotation>
+					<xsd:documentation>ObjektSpezifikation kann ab Version 1.3 entfallen, es kann aber sein, dass das Versicherungsunternehmen einen Fehler meldet, weil es Anfragen nur mit Objektspezifikation unterstützt oder weil die Ergebnismenge zu groß wäre.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsResponse" type="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response mit einer Anzahl von Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="AnzDokumente" type="xsd:nonNegativeInteger"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectRequest" type="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines fachlichen Objekts zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectResponse" type="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodRequest" type="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines Zeitraums zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type" minOccurs="0"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodResponse" type="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:complexType name="DocumentInfosResponseResult_Type">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ActualOffset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Der tatsächliche Offset in der  Ergebnisliste.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ActualMaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Tatsächliche Maximalanzahl der Ergebnisse, die der Provider auf eine Anfrage zurück gibt. Beispiel: Consumer fordert 1000 Ergebnisse an, Provider liefert aber maximal 100 zurück. In diesem Fall würde hier 100 zurückgegeben. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="TotalResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Gesamtzahl der Dokumente unter dem gewählten Filter.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="DokumentInfos" type="cst:DokumentenReferenz_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="AcknowledgeDocumentsRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Bestätigung eines Posteingangs durch Vermittler bzw. seinen technischen Dienstleister</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Die Vermittlernummer oder die Vermittlernummern, für die der Posterhalt bestätigt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="ErhaltBestaetigt" type="omds:Datum" maxOccurs="1">
+							<xsd:annotation>
+								<xsd:documentation>Der Zeitpunkt, bis zu welchem der Erhalt der Post bestätigt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="AcknowledgeDocumentsResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Bestätigung eines Posteingangs durch den Makler</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type"/>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- GetStateChanges -->
+	<xsd:annotation>
+		<xsd:documentation>State-Changes</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="GetStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjektes um Geschäftsfalle abzuholen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonSearchRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="GeschaeftsobjektArt" type="cst:GeschaeftsobjektArt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vorgabe einer Geschäftsobjektart, z.B. Vertrag, Schaden oder Antrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjektes um Geschäftsfalle abzuholen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonSearchResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Event" type="AbstractStateChangeEvent_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetStateChangesRequest" type="GetStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Abfrage von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetStateChangesResponse" type="GetStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Abfrage von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AbstractStateChangeEvent_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Event einer Statusänderung </xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaeftsfallEreignis_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ereignis in einem Geschäftsprozess, z.B. der Abschluss eines Arbeitsschritts im Prozess</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStateChangeEvent_Type">
+				<xsd:sequence>
+					<xsd:element name="Id" type="xsd:string" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Id des Ereignisses</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vermnr" type="omds:Vermnr"/>
+					<xsd:element name="Geschaeftsfallnummer" type="xsd:string"/>
+					<xsd:element name="GeschaeftsfallArt" type="cst:GeschaeftsfallArt_Type"/>
+					<xsd:element name="Zeitpunkt" type="omds:Datum-Zeit"/>
+					<xsd:element name="Txt" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional ein kurzer Text, welcher das Event beschreibt. Hinweis: Geschäftsfallereignisse müssen nicht gelesen werden. Die Verarbeitung von Hinweistexten durch den Vermittler ist optional.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:maxLength value="255"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="BisherigerStatus" type="GeschaeftsfallStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bisheriger allgemeiner Status des Geschäftsfalls vor Eintreten des Ereignisses.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Status" type="GeschaeftsfallStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>Aktueller allgemeiner Status des Geschäftsfalls durch Eintreten des Ereignisses.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokument" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Dokument, welches die Änderung belegt</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="DokumentId" type="xsd:string"/>
+								<xsd:element name="Typ" type="cst:DocumentType"/>
+							</xsd:sequence>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="Objekt" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Betroffene Objekte</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="Objektart" type="cst:GeschaeftsobjektArt_Type">
+									<xsd:annotation>
+										<xsd:documentation>Die Art des Objekts, z.B. Vertrag</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="ObjektId" type="cst:ObjektId_Type">
+									<xsd:annotation>
+										<xsd:documentation>Die Id des Objekts als ObjektId_Type</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="ArtAenderung" type="cst:ArtAenderung_Type">
+									<xsd:annotation>
+										<xsd:documentation>Grundsätziche Art der Änderung: Angelegt, Geändert, Gelöscht, Unverändert</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="GueltigAb" type="omds:Datum">
+									<xsd:annotation>
+										<xsd:documentation>Das Datum ab welchem die Statusänderung wirksam wird.</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="BisherigerStatus" type="xsd:string" minOccurs="0">
+									<xsd:annotation>
+										<xsd:documentation>Optional der bisherige Status</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="Status" type="xsd:string">
+									<xsd:annotation>
+										<xsd:documentation>Aktueller Status des Geschäftsobjekts</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="Dokument" minOccurs="0" maxOccurs="unbounded">
+									<xsd:annotation>
+										<xsd:documentation>Dokument, welches die Änderung belegt</xsd:documentation>
+									</xsd:annotation>
+									<xsd:complexType>
+										<xsd:sequence>
+											<xsd:element name="DokumentId" type="xsd:string"/>
+											<xsd:element name="Typ" type="cst:DocumentType"/>
+										</xsd:sequence>
+									</xsd:complexType>
+								</xsd:element>
+							</xsd:sequence>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaeftsfallEreignisAntrag_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ereignis in einem Geschäftsprozess vom Typ Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="GeschaeftsfallEreignis_Type">
+				<xsd:sequence>
+					<xsd:element name="AntragsId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>AntragsId oder Antragsnummer</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BisherigerAntragsstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0"/>
+					<xsd:element name="Antragsstatus" type="cst:SubmitApplicationStatus_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaeftsfallEreignisSchaden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ereignis in einem Geschäftsprozess vom Typ Schaden</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="GeschaeftsfallEreignis_Type">
+				<xsd:sequence>
+					<xsd:element name="BisherigerBearbStandCd" type="omds:BearbStandCd_Type" minOccurs="0"/>
+					<xsd:element name="BearbStandCd" type="omds:BearbStandCd_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="GeschaeftsfallStatus_Type">
+		<xsd:annotation>
+			<xsd:documentation>Allgemeiner generischer Status für alle Arten von Geschäftsprozessen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Erzeugt">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wurde angelegt, aber noch nicht gestartet.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Laufend">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wird ausgeführt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Unterbrochen">
+				<xsd:annotation>
+					<xsd:documentation>An dem Prozess wird nicht mehr gearbeitet. Die Arbeit kann später wieder aufgenommen werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Wartet">
+				<xsd:annotation>
+					<xsd:documentation>An dem Prozess wird nicht gearbeitet, da auf Rückmeldung vom Vermittler gewartet wird.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Abgebrochen">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wurde dauerhaft abgebrochen ohne ein Ergebnis zu erreichen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Abgeschlossen">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wurde mit Ergebnis abgeschlossen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="StateChangeEvent_Type">
+		<xsd:annotation>
+			<xsd:documentation>Deprecated: Verwende statt dessen GeschaeftsfallEreignis_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStateChangeEvent_Type">
+				<xsd:sequence>
+					<xsd:element name="Objektart" type="cst:GeschaeftsobjektArt_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Art des Objekts, z.B. Vertrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ObjektId" type="cst:ObjektId_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Id des Objekts als ObjektId_Type</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eine Geschäftsfall-Id als String, wenn dem Servicenutzer eine solche zugeordnet ist.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GeschaeftsfallArt" type="cst:GeschaeftsfallArt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Art des Geschaeftsfalls der zur Statusänderung geführt hat.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Aenderungsdatum" type="omds:Datum-Zeit">
+						<xsd:annotation>
+							<xsd:documentation>Das Datum ab wann die Statusänderung feststeht.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="StatusGueltigAbDatum" type="omds:Datum-Zeit">
+						<xsd:annotation>
+							<xsd:documentation>Das Datum ab welchem die Statusänderung wirksam wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BisherigerStatus" type="AbstractStatusGeschaeftsfall_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional der bisherige Status</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="NeuerStatus" type="AbstractStatusGeschaeftsfall_Type">
+						<xsd:annotation>
+							<xsd:documentation>Der neue Status</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AbstractStatusGeschaeftsfall_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Deprecated: Abstrakter Status eines Geschaeftsfalls</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="StatusAntragsGeschaeftsfall">
+		<xsd:annotation>
+			<xsd:documentation>Deprecated: Status eines Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStatusGeschaeftsfall_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Ende GetStateChanges -->
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,618 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ost="urn:omds3ServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<!--Prozessobjekte Berechnung, Offert, Antrag - Spartenübergreifend-->
+	<xsd:complexType name="SpezBOASchritt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrackter Basistyp für das Datenmodell aller BOA-Prozessschritte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SpezBerechnung_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Berechnung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBOASchritt_Type">
+				<xsd:sequence>
+					<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffert_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Offert, der bei Request und Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBOASchritt_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertnummer" type="cst:ObjektId_Type" minOccurs="0"/>
+					<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntrag_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBOASchritt_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsart" type="cst:Antragsart_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Antragsart kann auch vom ServiceProvider automatisch bestimmt werden, dann bleibt sie im Request leer.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle referenziert werden. Die Personen können eine Adresse enthalten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AbweichenderPraemienzahler" type="xsd:unsignedShort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf einen abweichenden Praemienzahler, wenn nicht der Versicherungsnehmer die Prämie zahlt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="WeitereVersicherungsnehmer" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf weitere Versicherungsnehmer</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="WeitereVertragspersonen" type="cst:Vertragsperson_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Weitere Personen in Vertragsrollen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AbgelehnteRisiken" type="cst:AbgelehnteRisiken_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bestehen Ablehnungen zu den beantragten Risiken</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vorversicherungen" type="cst:Vorversicherungen_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bestehende Vorversicherungen zu dem Antrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zahlungsdaten" type="cst:Zahlungsdaten_Type">
+						<xsd:annotation>
+							<xsd:documentation>Beschreibt die Art der Zahlung und enthält die zugehörigen Daten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Sepa" type="cst:SepaCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>SEPA-Mandat-Steuerung, wenn Zahlungsdaten ein SEPA-Mandat notwendig machen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Polizzenversand" type="cst:PolizzenversandType" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>alternativer Polizzenversand</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Datenschutzbestimmungen" type="cst:Datenverwendung_Type">
+						<xsd:annotation>
+							<xsd:documentation>Allgemeine Datenschutzbestimmungen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Kontierung" type="cst:Kontierung_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Ersatzpolizzennummer" type="cst:Ersatzpolizzen_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Ersatzpolizzennummern für eine manuelle Ablöse von Polizzen. Nicht für automatische Konvertierung oder Fahrzeugwechsel.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusendungWeitereDokumente" type="xsd:string" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Sollen weitere Antragsdokumente zugestellt werden (z.B. IVK)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheAntragsdaten" type="ZusaetzlicheAntragsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Sicherstellungen" type="cst:Sicherstellung_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Daten zu etwaigen Sicherstellungen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Einwilligungen" type="cst:Einwilligung_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Zustimmung zu vorgegebenen Fragen, z.B. Datenverarbeitung von Gesundheitsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Polizzennr" type="omds:Polizzennr" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional eine Polizzennr, z.B. als Response, wenn sofort polizziert wurde.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VertragsID" type="omds:VertragsID" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional eine VertragsID, z.B. als Response, wenn sofort polizziert wurde.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragPersonen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag in der Personenversicherung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="FATCA" type="cst:FATCA_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Informationen zu FATCA.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GSGM" type="cst:GMSG_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Informatiionen zum Gemeinsamer Meldestandard-Gesetz bzw. EU Richtlinie zum Austausch von Steuerinformationen. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PEP" type="cst:PEP_Type">
+						<xsd:annotation>
+							<xsd:documentation>Angabe PEP ist zwingend</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Treuhaenderfrage" type="cst:Treuhaenderfrage_Type">
+						<xsd:annotation>
+							<xsd:documentation>Wird der Vertrag treuhänderisch gehalten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Abstrakte BOA-Operationstypen-->
+	<xsd:complexType name="BOAProcessRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Zwischenelement für alle BOA-Request-Types</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Aenderungsgrund" type="omds:AendGrundCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated - die Angabe eines Aenderungsgrunds. Künftig sollte der Aenderungsgrund im Element Ersatzpolizzen angegeben werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Ersatzpolizzen" type="cst:Ersatzpolizze_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Polizzennummern, die im Rahmen einer Konvertierung, einem Fahrzeugwechsel o.Ä. abgelöst werden sollen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="BOAProcessResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Zwischenelement für alle BOA-Response-Types</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Aenderungsgrund" type="omds:AendGrundCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated - die Angabe eines Aenderungsgrunds. Künftig sollte der Aenderungsgrund im Element Ersatzpolizzen angegeben werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Ersatzpolizzen" type="cst:Ersatzpolizze_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Polizzennummern, die im Rahmen einer Konvertierung, einem Fahrzeugwechsel o.Ä. abgelöst werden sollen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="RequestUpselling" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation>Sollen Upselling-Vorschläge mitberechnet werden? Wenn ja kann dies zu einer längeren Berechnungsdauer führen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Ergebnis der Berechnung enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für das Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Offert enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated, verwende statt dessen DokumenteAnforderungen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DokumenteAnforderungen" type="cst:ProzessDokumentBasis_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier sind 3 Arten von Dokumenten enthalten: Solche, die der Kunde nur ausgefolgt bekommt, solche, die er unterschrieben zurück liefern soll und Anforderung von beizubringenden Dokumenten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für den Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Verwende künftig Dokumente.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:ProzessDokument_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>(Unterschriebene) Dokumente zum Antrag, möglicher Weise auf Anforderung hin.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der den Antrag enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>optional ein aktueller Status des Antragsprozess</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn der Antrag fehlerfrei erstellt werden konnte, die Referenz auf diesen Antrag. Diese Referenz ist bei der Einreichung des Antrags anzugegeben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Verwende künftig DokumenteAnforderungen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DokumenteAnforderungen" type="cst:ProzessDokumentBasis_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier sind 3 Arten von Dokumenten enthalten: Solche, die der Kunde nur ausgefolgt bekommt, solche, die er unterschrieben zurück liefern soll und Anforderung von beizubringenden Dokumenten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Verwende künftig Dokumente.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:ProzessDokument_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>(Unterschriebene) Dokumente zum Antrag, möglicher Weise auf Anforderung hin.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Referenz auf einen zuvor mit CreateApplication erzeugten Antrag, welcher jetzt eingereicht werden soll. Diese Referenz wird durch CreateApplication erzeugt. Entweder ist solch ein Bezug zu einem vorangegangenen SubmitApplication mitzugeben oder nochmals die Daten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>aktueller Status des eingespielten Antrages</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated, verwende künftig DokumenteAnforderungen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DokumenteAnforderungen" type="cst:ProzessDokumentBasis_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier sind 3 Arten von Dokumenten enthalten: Solche, die der Kunde nur ausgefolgt bekommt, solche, die er unterschrieben zurück liefern soll und Anforderung von beizubringenden Dokumenten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response Berechnung </xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Offerterstellung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Offerterstellung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragserzeugung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragserzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragsüberleitung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheAntragsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung des Antrags um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokumentId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>Eine DokumentenId als String</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokument" type="cst:DokumentInfo_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetApplicationDocumentRequest" type="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetApplicationDocumentResponse" type="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="ConversionScopeRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request um die Konvertierungsmöglichkeiten für einen oder mehrere Verträge zu erhalten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="Vertrag" type="cst:Ersatzpolizze_Type" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Angabe für welche Verträge die Konvertierung geplant ist.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="ConversionScopeResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response mit den Konvertierungsmöglichkeiten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="Konvertierungsmoeglichkeit" type="Konvertierungsumfang_Type">
+							<xsd:annotation>
+								<xsd:documentation>Eine Konvertierungsmöglichkeit oder mehrere Möglichkeiten.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="ConversionProposalRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request um einen Konvertierungsvorschlag zu generieren</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="Konvertierungsplan" type="Konvertierungsumfang_Type">
+							<xsd:annotation>
+								<xsd:documentation>Angabe auf welchem Vertrag oder welchen Verträgen der neue Vertrag aufgebaut werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="ConversionProposalResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response um mit einem Konvertierungsvorschlag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="Vorschlag" type="SpezAntrag_Type" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Vorschlag für den Antrag des konvertierten Vertrags.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Dokument" type="cst:ProzessDokHandout_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Möglichkeit um Konvertierungsübersicht (Gegenüberstellung von Deckungen) mitzugeben.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Ersatzpolizze" type="cst:Ersatzpolizze_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Polizzennummern, die im Rahmen der Konvertierung abgelöst werden sollen.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:complexType name="Konvertierungsumfang_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifiziert die Konvertierung mehrerer Verträge in einen neuen Vertrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Vertrag" type="cst:KonvertierungsumfangVertrag_Type" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,694 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>Produktmodell Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="VerkaufsproduktKfz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Verkaufsprodukt_Type">
+				<xsd:sequence>
+					<xsd:element name="Gebdat" type="xsd:date" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Geburtsdatum als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PLZ" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PLZ als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="7"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="PersArtCd" type="omds:PersArtCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PersonArtCd als Tarifmerkmal: N = nat. Person, S = sonst. Person</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="KfzVersicherung" type="ProduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="KfzZusatzVersicherung" type="ZusatzproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteFahrzeuge" type="cst:Fahrzeug_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>In Analogie zum OMDS-Datensatz befinden sich die Risikoobjekte als Element in der obersten Produktebene (OMDS Datensatz Element VERTRAG)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produkt, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element name="Haftpflicht" type="HaftpflichtKfz_Type" minOccurs="0"/>
+					<xsd:choice>
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Kann fuer Wechselkennzeichen nicht verwendet werden. Verwende statt dessen Elemente "Kasko".</xsd:documentation>
+						</xsd:annotation>
+						<xsd:element name="Teilkasko" type="TeilkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+						<xsd:element name="Vollkasko" type="VollkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:choice>
+					<xsd:element name="Kasko" type="KaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Insassenunfall" type="InsassenUnfallKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Assistance" type="AssistanceKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Zusatzprodukte, die mit einer KFZ-Versicherung gebündelt werden können.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+					<xsd:element name="LeasingVerbundUnternehmen" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="HaftpflichtKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Haftpflicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Haftpflicht erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element ref="omds:EL-Versicherungssumme">
+						<xsd:annotation>
+							<xsd:documentation>Versicherungssumme Haftpflicht</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VarianteLeihwagen" type="VarianteLeihwagen_Type"/>
+					<xsd:element ref="omds:EL-Einstufung"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="VDNummer" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="KaskoKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für die Kasko-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Teilkasko bzw. KFZ-Vollkasko erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SelbstbehaltBisBetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="KMLeistung" type="xsd:unsignedInt" minOccurs="0"/>
+					<xsd:element name="VorsteuerAbzugBerechtigung" type="xsd:boolean"/>
+					<xsd:element name="Vinkulierung" type="cst:Vinkulierung_Type" minOccurs="0"/>
+					<xsd:element name="Bezugsrecht" type="cst:Bezugsrecht_Type" minOccurs="0"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Eingeschraenkt" type="xsd:boolean" default="0" minOccurs="0"/>
+					<xsd:element name="Neuwertklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TeilkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Teilkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Vandalismusklausel" type="xsd:boolean"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VollkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Vollkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Leasingklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="InsassenUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Insassenunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="InsassenUnfallSystem" type="InsassenUnfallSystem_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LenkerUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Lenkerunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AssistanceKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Assistance</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfzRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Kfz-Rechtsschutz-Versicherung, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkehrsrechtsschutz" type="VerkehrsrechtsschutzKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VerkehrsrechtsschutzKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Verkehrsrechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Typen für die BOA-Services fuer Kfz -->
+	<xsd:complexType name="SpezBerechnungKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antragsanfrage und Antragsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+					<xsd:element name="BonusMalus" type="cst:BonusMalusSystem_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>BonusMalus beim Verband</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vinkulierung" type="cst:Vinkularglaeubiger_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vinkulierungsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheKfzDaten" type="ZusaetzlicheKfzdaten_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingKfzResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Alternativen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="UpsellingVerkaufsprodukte" type="VerkaufsproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Berechnung die Details der Berechnung.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ResponseUpselling" type="UpsellingKfzResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Request für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Response für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Erstellung eines Offerts.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="SpezOffertKfz_Type"/>
+							</xsd:complexContent>
+							<!-- Jens Buehring 16.9.2021: Dieser anonyme Innertype ist unnoetig und weicht vom Schema der anderen Requests ab. Aus Gruenden der Abwaertskompatibilitaet muss es aber bis zu einem Refactoring so stehen bleiben. -->
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional die Daten des Antrags, wenn nicht Bezug auf ein vorangegangenes SubmitApplication genommen wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Hier werden nochmals alle Antragsdaten zur Verfügung gestellt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Konkrete Services (Request- und Responseobjekte) Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="CalculateKfzRequest" type="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Kfz Berechnung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateKfzResponse" type="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzRequest" type="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Kfz Offert</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzResponse" type="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offert Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzRequest" type="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für einen Kfz Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzResponse" type="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antrag Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzRequest" type="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzResponse" type="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="FahrzeugRefLfdNr" type="xsd:string">
+		<xsd:annotation>
+			<xsd:documentation>Refernziert auf ein versichertes Fahrzeug über die laufende Nummer innerhalb eines Elementarprodukts.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="VorversicherungenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorversicherungen, Implementierung speziell für Kfz. Alternativ siehe auch allgemeine spartenübergreifende Implementierung cst:VorversicherungenImpl_Type.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Vorversicherungen_Type">
+				<xsd:sequence>
+					<xsd:element name="VorversicherungKfz" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="cst:VorversicherungenDetail_Type">
+									<xsd:attribute name="VtgSparteCd" type="omds:VtgSparteCd_Type" use="optional"/>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="VorversicherungRechtsschutz" type="cst:VorversicherungenDetail_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="InsassenUnfallSystem_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type System Insassenunfallversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Pauschalsystem"/>
+			<xsd:enumeration value="Platzsystem1"/>
+			<xsd:enumeration value="Platzsystem2"/>
+			<xsd:enumeration value="Personensystem"/>
+			<xsd:enumeration value="Lenkerunfallversicherung"/>
+			<xsd:enumeration value="Aufsassenunfallversicherung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="VarianteLeihwagen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Variante Leihwagen (A, B)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="VA">
+				<xsd:annotation>
+					<xsd:documentation>ohne Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VB">
+				<xsd:annotation>
+					<xsd:documentation>mit Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Zusätzliche KFZ-Daten -->
+	<xsd:complexType name="ZusaetzlicheKfzdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zusätzliche Kfz-Daten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="KfzKennzeichen">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="3"/>
+						<xsd:maxLength value="9"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="Fahrgestellnummer" type="Fahrgestellnummer_Type"/>
+			<xsd:element name="ErfolgtAnmeldungZeitgleichMitAbmeldung" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="AbmeldedatumWechselkennzeichenFahrzeug" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="Wechselkennzeichen" type="Wechselkennzeichen_Type" minOccurs="0"/>
+			<xsd:element name="Fahrzeugzustand" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Fahrzeugzustand als Schlüsselwerte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="FzZustandBesichtigung" type="FzZustandBesichtigung_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Detailierte Fahrzeugzustandsbeschreibung z.B. aus einer Besichtigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdatenKfz" type="ZusaetzlicheAntragsdatenKfz_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Wechselkennzeichen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Wechselkennzeichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="WechselkennzeichenArt">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Neues Fahrzeug als WKZ in bestehenden Vertrag einbündeln"/>
+						<xsd:enumeration value="Fahrzeugwechsel im bestehenden WKZ-Vertrag"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="BestehenderWechselkennzeichenvertrag" type="xsd:string"/>
+			<xsd:element name="ErsetztWirdFahrgestellnummer" type="Fahrgestellnummer_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="Fahrgestellnummer_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Fahrgestellnummer FIN</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="30"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="FzZustandBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ergebnisse einer Besichtigung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ZustandsberichtLiegtAlsFormularBei" type="xsd:boolean" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zustandsbericht liegt als Formular bei bzw. Besichtigung durch externe Stelle veranlasst - muss dann als Attachment mitgeschickt werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArtBesichtigung" type="ArtBesichtigung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Die Art der Besichtigung bzw. Quelle der Zustandsbeschreibung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="SchaedenAnScheibenKleinglas" type="SchaedenAnScheibenKleinglas_Type" minOccurs="0"/>
+			<xsd:element name="SchaedenAmFahrzeug" type="SchaedenAmFahrzeug_Type" minOccurs="0"/>
+			<xsd:element name="KilometerLtBesichtigung" type="xsd:integer" minOccurs="0"/>
+			<xsd:element name="Vorschaeden" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsort" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsdatum" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="GrundFuerNachbesichtigung" type="xsd:string" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="ArtBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Zustandsbeschreibung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Besichtigung durch Betreuer"/>
+			<xsd:enumeration value="Kaufvertrag Markenhaendler mit Beschreibung"/>
+			<xsd:enumeration value="Besichtigung durch ARBOE, OEAMTC"/>
+			<xsd:enumeration value="Nachbesichtigung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAnScheibenKleinglas_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Beschreibung Schäden an Kleinglas</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an Scheiben / Kleinglas"/>
+			<xsd:enumeration value="Schäden an Scheiben / Kleinglas"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAmFahrzeug_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Schäden am Fahrzeug</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an der Karosserie"/>
+			<xsd:enumeration value="Schäden an der Karosserie"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ZusaetzlicheAntragsdatenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ für VU-Spezifische Erweiterungen bei der Kfz-Beschreibung im Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:element name="CreateVBRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Versicherungsbestätigung zu generieren</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="Vermittlernr" type="omds:Vermnr" minOccurs="1">
+							<xsd:annotation>
+								<xsd:documentation>Vermittlernummer für welche die VB ausgestellt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Art">
+							<xsd:annotation>
+								<xsd:documentation>Neuanmeldung oder Wiederzulassung</xsd:documentation>
+							</xsd:annotation>
+							<xsd:simpleType>
+								<xsd:restriction base="xsd:string">
+									<xsd:enumeration value="NEU"/>
+									<xsd:enumeration value="WIEDER"/>
+								</xsd:restriction>
+							</xsd:simpleType>
+						</xsd:element>
+						<xsd:element name="Kennzeichen" type="omds:Pol_Kennz_Type" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Optional ein Kennzeichen, auf welches die VB beschränkt sein soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Polizzennr" type="omds:Polizzennr" minOccurs="0"/>
+						<xsd:element name="Fahrzeug" minOccurs="0" maxOccurs="3">
+							<xsd:annotation>
+								<xsd:documentation>Optional eine Liste von Fahrzeugen, auf deren Anmeldung die VB beschränkt sein soll.</xsd:documentation>
+							</xsd:annotation>
+							<xsd:complexType>
+								<xsd:sequence>
+									<xsd:element name="FzgArt" type="omds:FzgArtCd_Type"/>
+									<xsd:element name="MarkeType">
+										<xsd:simpleType>
+											<xsd:restriction base="xsd:string">
+												<xsd:maxLength value="20"/>
+											</xsd:restriction>
+										</xsd:simpleType>
+									</xsd:element>
+									<xsd:element name="Fahrgestnr" type="omds:Fahrgestnr_Type" minOccurs="0"/>
+								</xsd:sequence>
+							</xsd:complexType>
+						</xsd:element>
+						<xsd:element name="Versicherungsnehmer" type="cst:Person_Type">
+							<xsd:annotation>
+								<xsd:documentation>Spezifikation des Versicherungsnehmers</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="GueltigAb" type="omds:Datum" minOccurs="0"/>
+						<xsd:element name="VorlaeufigeDeckung" type="cst:VorlaeufigeDeckung_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Angaben zu gewünschten vorläufigen Deckungen (abseits von Haftpflicht)</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="ZusaetzlicheVBDaten" type="ZusaetzlicheVBDaten_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Erweiterungsmöglichkeit für VU-spezifische Daten</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateVBResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response bei der Generierung einer Versicherungsbestätigung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="VBNr" type="xsd:string"/>
+						<xsd:element name="VBDokument" type="cst:ProzessDokHandout_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:complexType name="ZusaetzlicheVBDaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Erweiterungsmöglichkeit für Versicherungsbestaetigung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON2_Antrag_Kranken.xsd

@@ -0,0 +1,244 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-6-0.on2antrag.kranken" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-6-0.on2antrag.kranken" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VerkaufsproduktKranken_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Krankenversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Krankenprodukte" type="ProduktKranken_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste von Produkten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Möglichkeit Kranken-fremde Bausteine einzugliedern.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VersichertePersonen" type="cst:VersichertePerson_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Risikodaten der versicherten Personen (als versicherte Interessen), die im Produktbaum über die Lfnr referenziert werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Gruppe" type="xsd:string" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf eine Gruppe</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Kranken. Von diesem Typ können einzelne VUs ihre eigenen Produkte ableiten, wenn sie möchten.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktMitVp_Type">
+				<xsd:sequence>
+					<xsd:element name="Elementarprodukte" type="ElementarproduktKranken_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der Elementarprodukte</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Selbstbehalt über alle Elementarprodukte einheitlich.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Kranken. Von diesem Typ werden etwaige unternehmesspezifische Deckungen oder potentielle Standard-Deckungen abgeleitet.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKranken_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Offert-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKranken_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Antrags-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKranken_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Elemente für die Methoden -->
+	<xsd:element name="CalculateKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Requestobjekts für eine Berechnung Kranken</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CalculateRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CalculateKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Responseobjekts für eine Kranken-Berechnung</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CalculateResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsantwort" type="SpezBerechnungKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Kranken-Offerts</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateOfferRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertanfrage" type="SpezOffertKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Kranken-Offerts</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateOfferResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertantwort" type="SpezOffertKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Requestobjekts für die Erstellung eines Krankenantrags</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntragKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Responseobjekts für die Erstellung eines Krankenantrags</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntragKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntragKranken_Type" minOccurs="0"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntragKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON2_Antrag_Leben.xsd

@@ -0,0 +1,335 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-5-0.on2antrag.leben" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-5-0.on2antrag.leben" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VerkaufsproduktLeben_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Leben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="LebenProdukte" type="ProduktLeben_Type" maxOccurs="unbounded"/>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Möglichkeit Zusatzprodukte anderer Sparten einzugliedern</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VersichertePersonen" type="cst:VersichertePerson_Type" minOccurs="1" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Risikoeigenschaften der versicherten Personen, die im Produktbaum referenziert werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Leben.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktMitVp_Type">
+				<xsd:sequence>
+					<xsd:element name="Tarife" type="TarifLeben_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der Tarife</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TarifLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Leben.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="GarantierteAblebenssumme" type="VersicherungssummeZusatzbaustein_Type" minOccurs="0"/>
+					<xsd:element name="Rentenoption" type="Rentenoption_Type" minOccurs="0"/>
+					<xsd:element name="Fondsauswahl" type="cst:ElementFondsauswahl_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Bei fondsgebundenen Produkten die Vorgabe der gewünschten Fonds.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zusatzbausteine" type="ZusatzversicherungLeben_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste von Zusatzbausteinen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Zusatzversicherung in der Sparte Leben (unterhalb von Elementarprodukt)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ZusatzproduktGenerisch_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Spezielle vorgefertigte Typen-->
+	<xsd:complexType name="ZusatzversicherungBerufsunfaehigkeit_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung Berufsunfähigkeit</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Wartefrist" type="Wartefrist_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungErwerbsunfaehigkeit_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung Erwerbsunfähigkeit</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Wartefrist" type="Wartefrist_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungPraemienuebernahmeAbleben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Praemienuebernahme im Ablebensfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Wartefrist" type="Wartefrist_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungUnfalltod_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung bei Unfalltod</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Versicherungssumme" type="VersicherungssummeZusatzbaustein_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungUnfallinvaliditaet_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung bei Unfallinvaliditaet</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Versicherungssumme" type="VersicherungssummeZusatzbaustein_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ um Zusatzprodukte (Ebene Produkt) im Verkausfprodukt Leben zu definieren</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="Rentenoption_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Rentenoption</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="Wartefrist_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Element zur Abbildung einer Wartefrist</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="VersicherungssummeZusatzbaustein_Type">
+		<xsd:annotation>
+			<xsd:documentation>Definition einer Versicherungssumme in einem Zusatzbaustein</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="ProzentVersicherungssumme" type="cst:AttributDouble_Type" minOccurs="0"/>
+			<xsd:element name="Betrag" type="cst:AttributDezimal_Type" minOccurs="0"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Offert-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Antrags-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntragPersonen_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen und Elemente für die Methoden -->
+	<xsd:complexType name="CalculateLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Leben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Leben-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungLeben_Type"/>
+					<xsd:element name="Upsellingvarianten" type="SpezBerechnungLeben_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Leben-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Leben-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="SpezOffertLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requestobjekts für die Erstellung eines Leben-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für die Erstellung eines Leben-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragLeben_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateLebenRequest" type="CalculateLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateLebenResponse" type="CalculateLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferLebenRequest" type="CreateOfferLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferLebenResponse" type="CreateOfferLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationLebenRequest" type="CreateApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationLebenResponse" type="CreateApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationLebenRequest" type="SubmitApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationLebenResponse" type="SubmitApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON2_Antrag_SachPrivat.xsd

@@ -0,0 +1,683 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VersichertesObjektSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type für ein versichertes Objekt in der Sach-Privat-Versicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="ObjektId" type="cst:ObjektId_Type" minOccurs="0"/>
+					<xsd:element name="RisikoAdresse" type="RisikoAdresse_Type"/>
+					<xsd:element name="RisikoGebaeude" type="RisikoGebaeude_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="RisikoHaushalt" type="RisikoHaushalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoAdresse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Beschreibung einer Risikoadresse</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="omds:ADRESSE_Type">
+				<xsd:sequence>
+					<xsd:element name="Horazone" type="xsd:unsignedByte" minOccurs="0"/>
+					<xsd:element name="ImVerbautenOrt" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="AusserhalbDesOrtsgebiets" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="ErreichbarkeitFuerLoeschfahrzeuge" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Tarifzone" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoHaushalt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Risikobeschreibung Haushalt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="Wohnflaeche" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Wohnfläche in qm</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AusstattungCd" type="omds:AusstattungCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>zweckmäßig, standard, gehoben...</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="NutzungCd" type="omds:NutzungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>ständig bewohnt, nicht-ständig bewohnt, unbewohnt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheHaushaltDaten" type="ZusaetzlicheHaushaltsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Erweiterungsmöglichkeit für weitere benötigte Daten, die nicht im Standard enthalten sind.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoGebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Risikobeschreibung Gebäude</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="GebaeudeArtCd" type="omds:GebaeudeArtCd_Type"/>
+					<xsd:element name="GebaeudeBez" type="xsd:string"/>
+					<xsd:element name="NutzungCd" type="omds:NutzungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>ständig bewohnt, nicht-ständig bewohnt, unbewohnt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BauartCd" type="omds:BauartCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Fertigteil, massiv, Holz...</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DachungCd" type="omds:DachungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>hart, nicht-hart</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GebaeudeHoeheCd" type="omds:GebaeudeHoeheCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Ebenerdig, 1 Stockwerk, 2 Stockwerke oder mehr als 2 Stockwerke</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BaujahrGebaeude" type="xsd:integer" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Jahreszahl</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="EL-Flaeche" type="omds:EL-Flaeche_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<!-- EL-Flaeche aus OMDS 2.10 -->
+					<xsd:element name="Vorschaeden" type="RisikoVorschaeden_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>wenn Vorschäden vorhanden sind, Typ des Schadens definieren</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AusstattungCd" type="omds:AusstattungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>zweckmäßig, standard, gehoben... (bei Gebäude oder nur in Haushalt?)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SichergKz" type="omds:Entsch2_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eigentumsrechte einer Bank ja / nein</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PreisProQm" type="omds:decimal" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Gebäude oder doch Ausstattung?</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheGebaeudedaten" type="ZusaetzlicheGebaeudedaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Erweiterungsmöglichkeit für weitere benötigte Daten, die nicht im Standard enthalten sind.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheHaushaltsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp zur Definition zusätzlicher Haushaltsdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp zur Definition zusätzlicher Gebäudedaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenWintergarten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Wintergarten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenSolarthermie_Type">
+		<xsd:annotation>
+			<xsd:documentation>Strandardbaustein Solarthermie</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenSchwimmbad_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Schwimmbad</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenPhotovoltaik_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Photovoltaik als Erweiterung von ZusaetzlicheGebaeudeDaten_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="RisikoVorschaeden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurden die Gebäude/der Wohnungsinhalt/Keller in den letzten 7 Jahren durch Hochwasser, Überschwemmung, Muren oder Lawinen beschädigt?</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Vorschaeden"/>
+			<xsd:enumeration value="ein Vorschaden"/>
+			<xsd:enumeration value="mehr als ein Vorschaden"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="Nebengebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für Nebengebäude</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Abstellgebaeude"/>
+			<xsd:enumeration value="Badehütte"/>
+			<xsd:enumeration value="Bootshaus"/>
+			<xsd:enumeration value="Carport"/>
+			<xsd:enumeration value="ehemaliges Wirtschaftsgebaeude"/>
+			<xsd:enumeration value="Garage"/>
+			<xsd:enumeration value="Gartenhaus (nicht für Wohnzwecke)"/>
+			<xsd:enumeration value="Holzhütte"/>
+			<xsd:enumeration value="Keller"/>
+			<xsd:enumeration value="Mobilheim (stationaer)"/>
+			<xsd:enumeration value="Nebengebaeude"/>
+			<xsd:enumeration value="Nebengebaeude mit Garage"/>
+			<xsd:enumeration value="Presshaus"/>
+			<xsd:enumeration value="Sauna"/>
+			<xsd:enumeration value="Scheune / Schuppen / Stadel"/>
+			<xsd:enumeration value="Werkstaette"/>
+			<xsd:enumeration value="Werkzeug- und Geraeteschuppen"/>
+			<xsd:enumeration value="Wintergarten, Veranda"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="VerkaufsproduktSachPrivat_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Besitz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Produkte" type="ProduktSachPrivat_Type" maxOccurs="unbounded"/>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteObjekte" type="cst:VersichertesInteresse_Type" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurzelelement für Sach-Privat-Produkte, auf welchem alle Sach-Privat Produkte aufbauen sollen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersObjekteRefLfnr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<!--					<xsd:element name="Elementarprodukte" type="ElementarproduktSachPrivat_Type" minOccurs="0" maxOccurs="unbounded"/>
+Jens Buehring entfernt 2.6.2020 weil die Untertypen spezifischere Listen haben (fuer Gebaeude und Haushalt) und wenn man selbst ein
+Unterobjekt definiert, sollte man seine eigene spezifische Loesung verwenden.
+-->
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="ProduktGebaeudeversicherung" type="ProduktGebaeudeversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischeres Element für Gebäudeversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="ProduktHaushaltsversicherung" type="ProduktHaushaltsversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischeres Element für Gebäudeinhaltversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ProduktGebaeudeversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für Gebaeudeversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ProduktSachPrivat_Type">
+				<xsd:sequence>
+					<xsd:element name="Deckungen" type="ElementarproduktGebaeude_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktHaushaltsversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für Gebäudeinhaltversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ProduktSachPrivat_Type">
+				<xsd:sequence>
+					<xsd:element name="Deckungen" type="ElementarproduktHaushalt_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurzelelement für Sach-Privat-Elementarprodukte, auf welchem alle Sach-Privat Elementarprodukte aufbauen sollen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersObjekteRefLfnr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Pauschalbetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+					<xsd:element name="Unterversicherungsverzicht" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="ProzentVersicherungssumme" type="xsd:unsignedShort" minOccurs="0"/>
+					<xsd:element name="Nebenkosten" type="cst:KostenFixOderProzent_Type" minOccurs="0"/>
+					<xsd:element name="Vorsorge" type="cst:KostenFixOderProzent_Type" minOccurs="0"/>
+					<xsd:element name="Hoechsthaftungssumme" type="omds:decimal" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktGebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für ein Gebäude-Elementarprodukt für einen Ansatz, in dem mit Vererbung für die einzelnen Sparten gearbeitet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktSachPrivat_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktHaushalt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für ein Gebäudeinhalts-Elementarprodukt für einen Ansatz, in dem mit Vererbung für die einzelnen Sparten gearbeitet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktSachPrivat_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GenElementarproduktGebaeude_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Elementarprodukt Gebäudeversicherung für einen Ansatz, in dem nicht mit Vererbung gearbeitet wird.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktGebaeude_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="GebaeudeSpartenCd_Type" minOccurs="1"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GenElementarproduktHaushalt_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Elementarprodukt Gebäudeinhaltsversicherung für einen Ansatz, in dem nicht mit Vererbung gearbeitet wird.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktHaushalt_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="HaushaltSpartenCd_Type" minOccurs="1"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="GebaeudeSpartenCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Basiert auf den Werten des SpartenCd_Type, diese Liste ist nur eingeschränkt auf die möglichen Gebäude Sparten Werte dürfen nur nach Aufnahme in den Basis-Typ hinzugefügt werden.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="999">
+				<xsd:annotation>
+					<xsd:documentation>sonstige</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="AS">
+				<xsd:annotation>
+					<xsd:documentation>Assistance</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="BU">
+				<xsd:annotation>
+					<xsd:documentation>Betriebs-Unterbrechung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ED">
+				<xsd:annotation>
+					<xsd:documentation>Einbruchdiebstahl</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="FE">
+				<xsd:annotation>
+					<xsd:documentation>Feuer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="GB">
+				<xsd:annotation>
+					<xsd:documentation>Glasbruch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HP">
+				<xsd:annotation>
+					<xsd:documentation>Haftpflicht</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="LW">
+				<xsd:annotation>
+					<xsd:documentation>Leitungswasser</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="MG">
+				<xsd:annotation>
+					<xsd:documentation>Maschinen und Geräte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="SS">
+				<xsd:annotation>
+					<xsd:documentation>Sonstige SV</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ST">
+				<xsd:annotation>
+					<xsd:documentation>Sturm</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="TI">
+				<xsd:annotation>
+					<xsd:documentation>Tierversicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="HaushaltSpartenCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Basiert auf den Werten des SpartenCd_Type, diese Liste ist nur eingeschränkt auf die möglichen Haushalt Sparten Werte dürfen nur nach Aufnahme in den Basis-Typ hinzugefügt werden.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="999">
+				<xsd:annotation>
+					<xsd:documentation>sonstige</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="AS">
+				<xsd:annotation>
+					<xsd:documentation>Assistance</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="BU">
+				<xsd:annotation>
+					<xsd:documentation>Betriebs-Unterbrechung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ED">
+				<xsd:annotation>
+					<xsd:documentation>Einbruchdiebstahl</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="EK">
+				<xsd:annotation>
+					<xsd:documentation>Elektronik</xsd:documentation>
+				</xsd:annotation>
+				<!-- deprecated, verwende EP -->
+			</xsd:enumeration>
+			<xsd:enumeration value="EP">
+				<xsd:annotation>
+					<xsd:documentation>Elektronik pauschal</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="FE">
+				<xsd:annotation>
+					<xsd:documentation>Feuer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="GB">
+				<xsd:annotation>
+					<xsd:documentation>Glasbruch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HH">
+				<xsd:annotation>
+					<xsd:documentation>Haushalt bzw. Wohnungs-Versicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HP">
+				<xsd:annotation>
+					<xsd:documentation>Haftpflicht</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="LW">
+				<xsd:annotation>
+					<xsd:documentation>Leitungswasser</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="MG">
+				<xsd:annotation>
+					<xsd:documentation>Maschinen und Geräte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="SS">
+				<xsd:annotation>
+					<xsd:documentation>Sonstige SV</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ST">
+				<xsd:annotation>
+					<xsd:documentation>Sturm</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="TI">
+				<xsd:annotation>
+					<xsd:documentation>Tierversicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!--Typen für die BOA-Services fuer Besitz -->
+	<xsd:complexType name="BerechnungSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="OffertSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AntragSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antraganfrage und Antragantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="BerechnungSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="BerechnungSachPrivat_Type"/>
+					<xsd:element name="ResponseUpselling" type="UpsellingSachPrivatResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für ein Offert Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="OffertSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für ein Offert Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="OffertSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für einen Antrag Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für einen Antrag Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="AntragSachPrivat_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateSachPrivatRequest" type="CalculateSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateSachPrivatResponse" type="CalculateSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferSachPrivatRequest" type="CreateOfferSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Offerterzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferSachPrivatResponse" type="CreateOfferSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offerterzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationSachPrivatRequest" type="CreateApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Antragserzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationSachPrivatResponse" type="CreateApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antragserzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationSachPrivatRequest" type="SubmitApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Antragseinreichung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationSachPrivatResponse" type="SubmitApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antragseinreichung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_10_0/omds3_ON2_Antrag_Unfall.xsd

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.unfall" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.unfall" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.10.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds215-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VerkaufsproduktUnfall_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Unfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Unfallprodukte" type="ProduktUnfall_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste von Produktbausteinen der Ebene 2, Produktbausteine von der Klasse "Versicherte Person"</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Möglichkeit Unfall-fremde Bausteine einzugliedern, z.B. Produkte aus Sach-Privat.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VersichertePersonen" type="cst:VersichertePerson_Type" minOccurs="1" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Risikodaten der versicherten Personen. Diese werden im Produktbaum auf Ebene 2 referenziert.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Unfall. Von diesem Typ können einzelne VUs ihre eigenen Produkte ableiten, wenn sie möchten.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktMitVp_Type">
+				<xsd:sequence>
+					<xsd:element name="Leistungsarten" type="LeistungsartUnfall_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der Elementarprodukte</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Selbstbehalt über alle Elementarprodukte einheitlich.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LeistungsartUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Unfall. Von diesem Typ werden etwaige unternehmesspezifische Deckungen oder potentielle Standard-Deckungen abgeleitet.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Offert-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Antrags-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen und Elemente für die Methoden -->
+	<xsd:complexType name="CalculateUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Unfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Unfall-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungUnfall_Type"/>
+					<xsd:element name="Upsellingvarianten" type="SpezBerechnungUnfall_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Unfall-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Unfall-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="SpezOffertUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requestobjekts für die Erstellung eines Unfallantrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für die Erstellung eines Unfallantrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragUnfall_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateUnfallRequest" type="CalculateUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateUnfallResponse" type="CalculateUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferUnfallRequest" type="CreateOfferUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferUnfallResponse" type="CreateOfferUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationUnfallRequest" type="CreateApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationUnfallResponse" type="CreateApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationUnfallRequest" type="SubmitApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationUnfallResponse" type="SubmitApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3ServiceTypes.xsd

@@ -0,0 +1,688 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3ServiceTypes-1-1-0" xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:omds3ServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<!-- Beziehe Action Link -->
+	<xsd:element name="loginRequest" type="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt für den Actionlink</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ des Request-Objekts fuer den allgemeinen Portaleinstieg</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="loginResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Der Actionlink z.B. in das Maklerportal mit einem Token, der die Verbindung zur Session herstellt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<!-- Beziehe User-Daten -->
+	<xsd:element name="getUserDataRequest" type="UserDataRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt fuer den Zugriff auf die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die VUNr des angefragten Unternehmens. Dies ermöglicht ggf. mehrere VUs über eine technische Lösung zu servicieren. Verwendet den Typ VUNr aus OMDS-Datensatz.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getUserDataResponse" type="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Das Ergebnisobjekt fuer die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Type mit Benutzerinformationen. Das Element 'address' ist mit Version 1.1.0 entfallen, da diese Informationen auch im Element 'person' übermittelt werden können
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="userid">
+				<xsd:annotation>
+					<xsd:documentation>BenutzerId</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="availableServices">
+				<xsd:annotation>
+					<xsd:documentation>Liste der für diesen User unterstützen Services</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="service" type="xsd:string" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Die ServiceId des jeweiligen Webservice als String</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="person" type="omds:PERSON_Type">
+				<xsd:annotation>
+					<xsd:documentation>Ist vom Typ PERSON_Type aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste verfuegbarer OMDS-Datensaetze -->
+	<xsd:element name="getOMDSPackageListRequest" type="OMDSPackageListRequest">
+		<xsd:annotation>
+			<xsd:documentation>Inputobjekt zum Beziehen einer Liste verfuegbarer OMDS-Datensaetze</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>die VUNr aus OMDS als optionaler Filterparameter</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>von inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>bis inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageListResponse" type="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabeobjekt für eine Liste von OMDS-Datensätzen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine Liste von OMDS-Datensaetzen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence minOccurs="0">
+			<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" minOccurs="0" maxOccurs="unbounded"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe einzelnen OMDS-Datensatz -->
+	<xsd:element name="getOMDSPackageRequest" type="OMDSPackageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Requestobjekt fuer die Abholung eines oder mehrerer OMDS-Datensatz-Packages</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageId" type="xsd:string" nillable="false" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Datensatzes unter welcher er ueber Webservices referenziert werden kann. Es handelt sich nicht um eine Id aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageResponse" type="OMDSPackageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Gibt die Liste der angeforderten OMDS-Packages zurück oder entsprechende fachliche Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageResponse">
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackage" type="RequestedOMDSPackage" nillable="false" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste der angeforderten Pakete</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="RequestedOMDSPackage">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer ein OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackageId" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Die angefragte Id des OMDS-Datenpakets, wobei dies kein Schlüssel aus dem Paket ist. </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="omdsPackage" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Nur enthalten, wenn es das angeforderte Paket tatsächlich gibt und der User darauf berechtigt ist.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" nillable="false">
+							<xsd:annotation>
+								<xsd:documentation>Meta-Informationen zu diesem Paket</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="content" type="xsd:base64Binary" xmime:expectedContentTypes="application/zip">
+							<xsd:annotation>
+								<xsd:documentation>Gezippte OMDS-Daten als base64Binary oder mit Binary mit MTOM</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="OMDSPackageInfoType">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die wesentlichen Informationen zu einem OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="MaklerID" type="cst:MaklerID_Type" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Entspricht der MaklerID in OMDS 2.x. Die MaklerID (in Version 1.0.0 noch AgentID) ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für die jeweilige VU oder den jeweiligen Dienstleister, bei dem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die agentID mit der Vermittlernummer "Vermnr" (in Version 1.0.0 noch agentNumber) zusammenfällt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des OMDS Pakets und Angaben zu ihrer Verwendbarkeit, wobei hier kein Schlüssel aus einem OMDS Paket selbst gemeint ist, sondern eine eigenständige Id, die das Abrufen des OMDS-Pakets ermöglicht.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="timeStamp" type="omds:Datum-Zeit" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Zeitstempel der Erstellung entsprechend dem Attribut PaketZpktErstell mit OMDS Datum-Zeit als Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageSize" type="xsd:int" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Groesse der Datei in Byte, de facto beschränkt auf max. ca. 2 GB da vom Typ int</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageExtent" type="omds:PaketUmfCd_Type">
+				<xsd:annotation>
+					<xsd:documentation>entspricht dem der Paketumfang wie er in OMDS 2.x im Typ PaketUmfCd_Type definiert ist: D = Differenz, G = Gesamtbestand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageContentCode" type="omds:PaketInhCd_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste von OMDS 2.x Elementen des Typs PaketInhCd_Type, die den Inhalt des Datenpakets beschreiben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste vertragsbezogener Dokumente -->
+	<xsd:element name="getArcImageInfosRequest" type="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfrage Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfragetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>die Polizzennummer als OMDS Polizzennr-Typ.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyType" type="omds:VtgProdCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für Polizzen eines bestimmten Typs. Das Attribut ist vom Typ VtgProdCd_Type des OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyPartnerRole" type="PolicyPartnerRole" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für bestimmte Partner in einer bestimmten Rolle</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf bestimmte Dokumententypen. Es gibt 15 definierte vertragsbezogene Dokumententypen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageInfosResponse" type="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabe Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Informationen zu Dokumenten, wenn vorhanden</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageRequest" type="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requesttyp zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArcImageId">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Dokuments vom Typ String</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<!--<xsd:element name="policy" type="Policy"/>-->
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageResponse" type="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responsetyp zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ArcContent" type="ArcContent" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Das Dokument und seine Meta-Informationen, wenn ein Dokument vorhanden war</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="PolicyPartnerRole">
+		<xsd:annotation>
+			<xsd:documentation>Partnerrollen in einer Polizze: Versicherungsnehmer, Versicherte Person</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS-Personennr (String mit 1-26 Zeichen) </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="partnerRole" type="cst:PartnerRoleType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Partnerrollen im Vertrag als PartnerRoleType: String mit 2 Zeichen: VN, VP</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcImageInfo">
+		<xsd:annotation>
+			<xsd:documentation>Information zu einem einzelnen Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Dokuments und Details zur Verwendung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="name" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Der Name des Dokuments als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType">
+				<xsd:annotation>
+					<xsd:documentation>Der inhaltliche Typ des Dokuments, z.B. "Polizze" oder "Finanzamtsbestätigung" als Integer-Code</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentType" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mime-Type des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentLength" type="xsd:long" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Größe des Dokuments in Byte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="date" type="xsd:date">
+				<xsd:annotation>
+					<xsd:documentation>Erstellungsdatum des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="docReference" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Verweis auf weitere Dokumente, die inhaltlich zu diesem Dokument gehören, z.B. AVB zu einer Polizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcContent">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument und das Dokument base64encoded</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Meta-Informationen zum Dokument (Deprecated, die Daten sollten dem Aufrufer schon bekannt sein)</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcImage" type="xsd:base64Binary" xmime:expectedContentTypes="application/octet-stream">
+				<xsd:annotation>
+					<xsd:documentation>Das eigentliche Dokument als base64-Binary</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe Deep-Links -->
+	<xsd:element name="getDeepLinkClaimRequest" type="DeepLinkClaimRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Schaden Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkClaimRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="claimNumber" type="omds:Schadennr">
+				<xsd:annotation>
+					<xsd:documentation>Schadennummer vom Typ OMDS Schadennr</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkClaimResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt Deep-Link Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPartnerRequest" type="DeepLinkPartnerRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPartnerRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS Personennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPartnerResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkOfferRequest" type="DeepLinkOfferRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot/ Antrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkOfferRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="offerNumber" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer der Berechnung, des Angebots oder des Antrags.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+
+	<xsd:simpleType name="Geschaeftsvorfall">
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Neuantrag"/>
+			<xsd:enumeration value="Aenderungsantrag"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:element name="getDeepLinkOfferResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot / Antrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPolicyRequest" type="DeepLinkPolicyRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPolicyRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer des Vertrags als OMDS Polizzennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPolicyResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkBusinessObjectResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Deep-Link auf Geschäftsobjekte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="withoutFrame" type="xsd:boolean">
+		<xsd:annotation>
+			<xsd:documentation>Soll ein Frame angezeigt werden oder nicht</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="httpActionLink" type="HttpActionLinkType"/>
+	<xsd:complexType name="HttpActionLinkType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen Deep-Link</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="url">
+				<xsd:annotation>
+					<xsd:documentation>String mit max. 1024 Zeichen</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="type">
+				<xsd:annotation>
+					<xsd:documentation>Code für Art der URL, z.B. Verträge, Dokumente, Schäden, Schadenmeldung als int-Type.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:int">
+						<xsd:enumeration value="1">
+							<xsd:annotation>
+								<xsd:documentation>Einstiegsseite</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="2">
+							<xsd:annotation>
+								<xsd:documentation>Suche Partner</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="3">
+							<xsd:annotation>
+								<xsd:documentation>Suche Vertrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="4">
+							<xsd:annotation>
+								<xsd:documentation>Suche Schaden</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="5">
+							<xsd:annotation>
+								<xsd:documentation>Suche Angebot/Antrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="6">
+							<xsd:annotation>
+								<xsd:documentation>Schadenübersicht</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden, keine Doublette zu Nr 12, da hier Übersicht über einzelnen Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="7">
+							<xsd:annotation>
+								<xsd:documentation>Dokumente</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="8">
+							<xsd:annotation>
+								<xsd:documentation>Anfrage</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="9">
+							<xsd:annotation>
+								<xsd:documentation>Stammdaten</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="10">
+							<xsd:annotation>
+								<xsd:documentation>Bearbeiten</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="11">
+							<xsd:annotation>
+								<xsd:documentation>Verträge</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="12">
+							<xsd:annotation>
+								<xsd:documentation>Schäden</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, Keine Doublette zu Nr 6 da hier eine Liste von Schäden zu einem gegebenen Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="13">
+							<xsd:annotation>
+								<xsd:documentation>Angebote</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner, keine Doublette zu Nr 14 Angebots-/ Antragsübersicht, da hier nur Angebote des Partners -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="14">
+							<xsd:annotation>
+								<xsd:documentation>Angebots-/ Antragsübersicht</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, keine Doublette zu Nr 13, da hier Übersichtsseite über alle Angebote/ Anträge des Service-Konsumenten -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="15">
+							<xsd:annotation>
+								<xsd:documentation>Inkassostand</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="16">
+							<xsd:annotation>
+								<xsd:documentation>Angebot</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="17">
+							<xsd:annotation>
+								<xsd:documentation>Schadenmeldung</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="18">
+							<xsd:annotation>
+								<xsd:documentation>Mahnungen</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="validUntil" type="xsd:dateTime" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ablaufzeitpunkt der Action-Links. Wenn Actionslinks vorhanden sind, dieses Element jedoch nicht oder mit dem Wert "null", so sind die ActionLinks zeitlich unbeschränkt gültig. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="DeepLinkBusinessObjectResponse">
+		<xsd:sequence>
+			<xsd:element name="httpActionLink" type="HttpActionLinkType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Linkbeschreibung vom Typ LinkType</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,507 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:element name="AddDocToBusinessCaseRequest" type="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts, um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type"/>
+			<xsd:element name="Dokument" type="cst:Upload_Dokument_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="AddDocToBusinessCaseResponse" type="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice maxOccurs="unbounded">
+			<xsd:element name="DocRef" type="cst:DokumentenReferenz_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsRequest" type="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Anzahl von Dokumenten zu einem fachlichen Objekt zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ enthält die Elemente fuer die Anfrage nach Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type">
+				<xsd:annotation>
+					<xsd:documentation>ObjektSpezifikation kann ab Version 1.3 entfallen, es kann aber sein, dass das Versicherungsunternehmen einen Fehler meldet, weil es Anfragen nur mit Objektspezifikation unterstützt oder weil die Ergebnismenge zu groß wäre.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsResponse" type="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response mit einer Anzahl von Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="AnzDokumente" type="xsd:nonNegativeInteger"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectRequest" type="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines fachlichen Objekts zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectResponse" type="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodRequest" type="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines Zeitraums zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type" minOccurs="0"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodResponse" type="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:complexType name="DocumentInfosResponseResult_Type">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ActualOffset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Der tatsächliche Offset in der  Ergebnisliste.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ActualMaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Tatsächliche Maximalanzahl der Ergebnisse, die der Provider auf eine Anfrage zurück gibt. Beispiel: Consumer fordert 1000 Ergebnisse an, Provider liefert aber maximal 100 zurück. In diesem Fall würde hier 100 zurückgegeben. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="TotalResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Gesamtzahl der Dokumente unter dem gewählten Filter.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="DokumentInfos" type="cst:DokumentenReferenz_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="AcknowledgeDocumentsRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Bestätigung eines Posteingangs durch Vermittler bzw. seinen technischen Dienstleister</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Die Vermittlernummer oder die Vermittlernummern, für die der Posterhalt bestätigt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="ErhaltBestaetigt" type="omds:Datum" maxOccurs="1">
+							<xsd:annotation>
+								<xsd:documentation>Der Zeitpunkt, bis zu welchem der Erhalt der Post bestätigt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="AcknowledgeDocumentsResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Bestätigung eines Posteingangs durch den Makler</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type"/>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- GetStateChanges -->
+	<xsd:annotation>
+		<xsd:documentation>State-Changes</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="GetStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjektes um Geschäftsfalle abzuholen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonSearchRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="GeschaeftsobjektArt" type="cst:GeschaeftsobjektArt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vorgabe einer Geschäftsobjektart, z.B. Vertrag, Schaden oder Antrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjektes um Geschäftsfalle abzuholen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonSearchResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Event" type="AbstractStateChangeEvent_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetStateChangesRequest" type="GetStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Abfrage von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetStateChangesResponse" type="GetStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Abfrage von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AbstractStateChangeEvent_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Event einer Statusänderung </xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaeftsfallEreignis_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ereignis in einem Geschäftsprozess, z.B. der Abschluss eines Arbeitsschritts im Prozess</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStateChangeEvent_Type">
+				<xsd:sequence>
+					<xsd:element name="Id" type="xsd:string" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Id des Ereignisses</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vermnr" type="omds:Vermnr"/>
+					<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="GeschaeftsfallArt" type="cst:GeschaeftsfallArt_Type"/>
+					<xsd:element name="Zeitpunkt" type="omds:Datum-Zeit"/>
+					<xsd:element name="Txt" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional ein kurzer Text, welcher das Event beschreibt. Hinweis: Geschäftsfallereignisse müssen nicht gelesen werden. Die Verarbeitung von Hinweistexten durch den Vermittler ist optional.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:maxLength value="255"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="BisherigerStatus" type="GeschaeftsfallStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bisheriger allgemeiner Status des Geschäftsfalls vor Eintreten des Ereignisses.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Status" type="GeschaeftsfallStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>Aktueller allgemeiner Status des Geschäftsfalls durch Eintreten des Ereignisses.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokument" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Dokument, welches die Änderung belegt</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="DokumentId" type="xsd:string"/>
+								<xsd:element name="Typ" type="cst:DocumentType"/>
+							</xsd:sequence>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="Objekt" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Betroffene Objekte</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="Objektart" type="cst:GeschaeftsobjektArt_Type">
+									<xsd:annotation>
+										<xsd:documentation>Die Art des Objekts, z.B. Vertrag</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="ObjektId" type="cst:ObjektId_Type">
+									<xsd:annotation>
+										<xsd:documentation>Die Id des Objekts als ObjektId_Type</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="ArtAenderung" type="cst:ArtAenderung_Type">
+									<xsd:annotation>
+										<xsd:documentation>Grundsätziche Art der Änderung: Angelegt, Geändert, Gelöscht, Unverändert</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="GueltigAb" type="omds:Datum">
+									<xsd:annotation>
+										<xsd:documentation>Das Datum ab welchem die Statusänderung wirksam wird.</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="BisherigerStatus" type="xsd:string" minOccurs="0">
+									<xsd:annotation>
+										<xsd:documentation>Optional der bisherige Status</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="Status" type="xsd:string">
+									<xsd:annotation>
+										<xsd:documentation>Aktueller Status des Geschäftsobjekts</xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element name="Dokument" minOccurs="0" maxOccurs="unbounded">
+									<xsd:annotation>
+										<xsd:documentation>Dokument, welches die Änderung belegt</xsd:documentation>
+									</xsd:annotation>
+									<xsd:complexType>
+										<xsd:sequence>
+											<xsd:element name="DokumentId" type="xsd:string"/>
+											<xsd:element name="Typ" type="cst:DocumentType"/>
+										</xsd:sequence>
+									</xsd:complexType>
+								</xsd:element>
+							</xsd:sequence>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaeftsfallEreignisAntrag_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ereignis in einem Geschäftsprozess vom Typ Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="GeschaeftsfallEreignis_Type">
+				<xsd:sequence>
+					<xsd:element name="AntragsId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>AntragsId oder Antragsnummer</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BisherigerAntragsstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0"/>
+					<xsd:element name="Antragsstatus" type="cst:SubmitApplicationStatus_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaeftsfallEreignisSchaden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ereignis in einem Geschäftsprozess vom Typ Schaden</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="GeschaeftsfallEreignis_Type">
+				<xsd:sequence>
+					<xsd:element name="BisherigerBearbStandCd" type="omds:BearbStandCd_Type" minOccurs="0"/>
+					<xsd:element name="BearbStandCd" type="omds:BearbStandCd_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="GeschaeftsfallStatus_Type">
+		<xsd:annotation>
+			<xsd:documentation>Allgemeiner generischer Status für alle Arten von Geschäftsprozessen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Erzeugt">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wurde angelegt, aber noch nicht gestartet.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Laufend">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wird ausgeführt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Unterbrochen">
+				<xsd:annotation>
+					<xsd:documentation>An dem Prozess wird nicht mehr gearbeitet. Die Arbeit kann später wieder aufgenommen werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Wartet">
+				<xsd:annotation>
+					<xsd:documentation>An dem Prozess wird nicht gearbeitet, da auf Rückmeldung vom Vermittler gewartet wird.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Abgebrochen">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wurde dauerhaft abgebrochen ohne ein Ergebnis zu erreichen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="Abgeschlossen">
+				<xsd:annotation>
+					<xsd:documentation>Der Prozess wurde mit Ergebnis abgeschlossen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="StateChangeEvent_Type">
+		<xsd:annotation>
+			<xsd:documentation>Deprecated: Verwende statt dessen GeschaeftsfallEreignis_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStateChangeEvent_Type">
+				<xsd:sequence>
+					<xsd:element name="Objektart" type="cst:GeschaeftsobjektArt_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Art des Objekts, z.B. Vertrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ObjektId" type="cst:ObjektId_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Id des Objekts als ObjektId_Type</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eine Geschäftsfall-Id als String, wenn dem Servicenutzer eine solche zugeordnet ist.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GeschaeftsfallArt" type="cst:GeschaeftsfallArt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Art des Geschaeftsfalls der zur Statusänderung geführt hat.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Aenderungsdatum" type="omds:Datum-Zeit">
+						<xsd:annotation>
+							<xsd:documentation>Das Datum ab wann die Statusänderung feststeht.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="StatusGueltigAbDatum" type="omds:Datum-Zeit">
+						<xsd:annotation>
+							<xsd:documentation>Das Datum ab welchem die Statusänderung wirksam wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BisherigerStatus" type="AbstractStatusGeschaeftsfall_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional der bisherige Status</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="NeuerStatus" type="AbstractStatusGeschaeftsfall_Type">
+						<xsd:annotation>
+							<xsd:documentation>Der neue Status</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AbstractStatusGeschaeftsfall_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Deprecated: Abstrakter Status eines Geschaeftsfalls</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="StatusAntragsGeschaeftsfall">
+		<xsd:annotation>
+			<xsd:documentation>Deprecated: Status eines Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStatusGeschaeftsfall_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Ende GetStateChanges -->
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,627 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ost="urn:omds3ServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<!--Prozessobjekte Berechnung, Offert, Antrag - Spartenübergreifend-->
+	<xsd:complexType name="SpezBOASchritt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für das Datenmodell aller BOA-Prozessschritte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SpezBerechnung_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Berechnung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBOASchritt_Type">
+				<xsd:sequence>
+					<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Liste aller benötigten Personen, welche dann über ihre Rolle referenziert werden. In der Berechnung ist dies nicht mehr vorgesehen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffert_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Offert, der bei Request und Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBOASchritt_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertnummer" type="cst:ObjektId_Type" minOccurs="0"/>
+					<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntrag_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBOASchritt_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsart" type="cst:Antragsart_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Antragsart kann auch vom ServiceProvider automatisch bestimmt werden, dann bleibt sie im Request leer.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle referenziert werden. Die Personen können eine Adresse enthalten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AbweichenderPraemienzahler" type="xsd:unsignedShort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf einen abweichenden Praemienzahler, wenn nicht der Versicherungsnehmer die Prämie zahlt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="WeitereVersicherungsnehmer" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf weitere Versicherungsnehmer</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="WeitereVertragspersonen" type="cst:Vertragsperson_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Weitere Personen in Vertragsrollen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AbgelehnteRisiken" type="cst:AbgelehnteRisiken_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bestehen Ablehnungen zu den beantragten Risiken</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vorversicherungen" type="cst:Vorversicherungen_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bestehende Vorversicherungen zu dem Antrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zahlungsdaten" type="cst:Zahlungsdaten_Type">
+						<xsd:annotation>
+							<xsd:documentation>Beschreibt die Art der Zahlung und enthält die zugehörigen Daten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Sepa" type="cst:SepaCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>SEPA-Mandat-Steuerung, wenn Zahlungsdaten ein SEPA-Mandat notwendig machen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Polizzenversand" type="cst:PolizzenversandType" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>alternativer Polizzenversand</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Datenschutzbestimmungen" type="cst:Datenverwendung_Type">
+						<xsd:annotation>
+							<xsd:documentation>Allgemeine Datenschutzbestimmungen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Kontierung" type="cst:Kontierung_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Ersatzpolizzennummer" type="cst:Ersatzpolizzen_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Ersatzpolizzennummern für eine manuelle Ablöse von Polizzen. Nicht für automatische Konvertierung oder Fahrzeugwechsel.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusendungWeitereDokumente" type="xsd:string" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Sollen weitere Antragsdokumente zugestellt werden (z.B. IVK)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheAntragsdaten" type="ZusaetzlicheAntragsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Sicherstellungen" type="cst:Sicherstellung_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Daten zu etwaigen Sicherstellungen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Einwilligungen" type="cst:Einwilligung_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Zustimmung zu vorgegebenen Fragen, z.B. Datenverarbeitung von Gesundheitsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Polizzennr" type="omds:Polizzennr" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional eine Polizzennr, z.B. als Response, wenn sofort polizziert wurde.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VertragsID" type="omds:VertragsID" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional eine VertragsID, z.B. als Response, wenn sofort polizziert wurde.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragPersonen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag in der Personenversicherung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="FATCA" type="cst:FATCA_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Informationen zu FATCA.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GSGM" type="cst:GMSG_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Informatiionen zum Gemeinsamer Meldestandard-Gesetz bzw. EU Richtlinie zum Austausch von Steuerinformationen. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PEP" type="cst:PEP_Type">
+						<xsd:annotation>
+							<xsd:documentation>Angabe PEP ist zwingend</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Treuhaenderfrage" type="cst:Treuhaenderfrage_Type">
+						<xsd:annotation>
+							<xsd:documentation>Wird der Vertrag treuhänderisch gehalten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Abstrakte BOA-Operationstypen-->
+	<xsd:complexType name="BOAProcessRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Zwischenelement für alle BOA-Request-Types</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Aenderungsgrund" type="omds:AendGrundCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated - die Angabe eines Aenderungsgrunds. Künftig sollte der Aenderungsgrund im Element Ersatzpolizzen angegeben werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Ersatzpolizzen" type="cst:Ersatzpolizze_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Polizzennummern beim gleichen Versicherer, die im Rahmen einer Konvertierung, einem Fahrzeugwechsel o.Ä. abgelöst werden sollen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="BOAProcessResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Zwischenelement für alle BOA-Response-Types</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Aenderungsgrund" type="omds:AendGrundCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated - die Angabe eines Aenderungsgrunds. Künftig sollte der Aenderungsgrund im Element Ersatzpolizzen angegeben werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Ersatzpolizzen" type="cst:Ersatzpolizze_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Polizzennummern, die im Rahmen einer Konvertierung, einem Fahrzeugwechsel o.Ä. abgelöst werden sollen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="RequestUpselling" type="xsd:boolean" default="false" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated, es kommt ein neuer Service ProductPropsal, welcher diese Rolle übernimmt. Sollen Upselling-Vorschläge mitberechnet werden? Wenn ja kann dies zu einer längeren Berechnungsdauer führen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Ergebnis der Berechnung enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für das Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokAnfordVermittler" type="cst:ProzessDokRequest_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Anforderung optionaler Dokumente durch den Client</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Offert enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated, verwende statt dessen DokumenteAnforderungen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DokumenteAnforderungen" type="cst:ProzessDokumentBasis_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier sind 3 Arten von Dokumenten enthalten: Solche, die der Kunde nur ausgefolgt bekommt, solche, die er unterschrieben zurück liefern soll und Anforderung von beizubringenden Dokumenten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für den Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokAnfordVermittler" type="cst:ProzessDokRequest_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Verwende künftig Dokumente.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:ProzessDokument_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>(Unterschriebene) Dokumente zum Antrag, möglicher Weise auf Anforderung hin.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der den Antrag enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>optional ein aktueller Status des Antragsprozess</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn der Antrag fehlerfrei erstellt werden konnte, die Referenz auf diesen Antrag. Diese Referenz ist bei der Einreichung des Antrags anzugegeben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Verwende künftig DokumenteAnforderungen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DokumenteAnforderungen" type="cst:ProzessDokumentBasis_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier sind 3 Arten von Dokumenten enthalten: Solche, die der Kunde nur ausgefolgt bekommt, solche, die er unterschrieben zurück liefern soll und Anforderung von beizubringenden Dokumenten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Verwende künftig Dokumente.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:ProzessDokument_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>(Unterschriebene) Dokumente zum Antrag, möglicher Weise auf Anforderung hin.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Referenz auf einen zuvor mit CreateApplication erzeugten Antrag, welcher jetzt eingereicht werden soll. Diese Referenz wird durch CreateApplication erzeugt. Entweder ist solch ein Bezug zu einem vorangegangenen SubmitApplication mitzugeben oder nochmals die Daten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BOAProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>aktueller Status des eingespielten Antrages</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated, verwende künftig DokumenteAnforderungen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DokumenteAnforderungen" type="cst:ProzessDokumentBasis_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier sind 3 Arten von Dokumenten enthalten: Solche, die der Kunde nur ausgefolgt bekommt, solche, die er unterschrieben zurück liefern soll und Anforderung von beizubringenden Dokumenten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response Berechnung </xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Offerterstellung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Offerterstellung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragserzeugung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragserzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragsüberleitung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheAntragsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung des Antrags um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokumentId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>Eine DokumentenId als String</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokument" type="cst:DokumentInfo_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetApplicationDocumentRequest" type="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetApplicationDocumentResponse" type="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="ConversionScopeRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request um die Konvertierungsmöglichkeiten für einen oder mehrere Verträge zu erhalten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="Vertrag" type="cst:Ersatzpolizze_Type" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Angabe für welche Verträge die Konvertierung geplant ist.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="ConversionScopeResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response mit den Konvertierungsmöglichkeiten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="Konvertierungsmoeglichkeit" type="Konvertierungsumfang_Type">
+							<xsd:annotation>
+								<xsd:documentation>Eine Konvertierungsmöglichkeit oder mehrere Möglichkeiten.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="ConversionProposalRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request um einen Konvertierungsvorschlag zu generieren</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="Konvertierungsplan" type="Konvertierungsumfang_Type">
+							<xsd:annotation>
+								<xsd:documentation>Angabe auf welchem Vertrag oder welchen Verträgen der neue Vertrag aufgebaut werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="ConversionProposalResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response um mit einem Konvertierungsvorschlag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="Vorschlag" type="SpezAntrag_Type" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Vorschlag für den Antrag des konvertierten Vertrags.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Dokument" type="cst:ProzessDokHandout_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Möglichkeit um Konvertierungsübersicht (Gegenüberstellung von Deckungen) mitzugeben.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Ersatzpolizze" type="cst:Ersatzpolizze_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Polizzennummern, die im Rahmen der Konvertierung abgelöst werden sollen.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:complexType name="Konvertierungsumfang_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifiziert die Konvertierung mehrerer Verträge in einen neuen Vertrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Vertrag" type="cst:KonvertierungsumfangVertrag_Type" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,715 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>Produktmodell Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="VerkaufsproduktKfz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Verkaufsprodukt_Type">
+				<xsd:sequence>
+					<xsd:element name="Gebdat" type="xsd:date" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Geburtsdatum als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PLZ" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PLZ als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="7"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="PersArtCd" type="omds:PersArtCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PersonArtCd als Tarifmerkmal: N = nat. Person, S = sonst. Person</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="KfzVersicherung" type="ProduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="KfzZusatzVersicherung" type="ZusatzproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteFahrzeuge" type="cst:Fahrzeug_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>In Analogie zum OMDS-Datensatz befinden sich die Risikoobjekte als Element in der obersten Produktebene (OMDS Datensatz Element VERTRAG)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produkt, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element name="Haftpflicht" type="HaftpflichtKfz_Type" minOccurs="0"/>
+					<xsd:choice>
+						<xsd:annotation>
+							<xsd:documentation>Deprecated: Kann fuer Wechselkennzeichen nicht verwendet werden. Verwende statt dessen Elemente "Kasko".</xsd:documentation>
+						</xsd:annotation>
+						<xsd:element name="Teilkasko" type="TeilkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+						<xsd:element name="Vollkasko" type="VollkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:choice>
+					<xsd:element name="Kasko" type="KaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Insassenunfall" type="InsassenUnfallKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Assistance" type="AssistanceKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Zusatzprodukte, die mit einer KFZ-Versicherung gebündelt werden können.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+					<xsd:element name="LeasingVerbundUnternehmen" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="HaftpflichtKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Haftpflicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Haftpflicht erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element ref="omds:EL-Versicherungssumme" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Versicherungssumme Haftpflicht</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VarianteLeihwagen" type="VarianteLeihwagen_Type"/>
+					<xsd:element ref="omds:EL-Einstufung"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="VDNummer" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="KaskoKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für die Kasko-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Teilkasko bzw. KFZ-Vollkasko erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SelbstbehaltBisBetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="KMLeistung" type="xsd:unsignedInt" minOccurs="0"/>
+					<xsd:element name="VorsteuerAbzugBerechtigung" type="xsd:boolean"/>
+					<xsd:element name="Vinkulierung" type="cst:Vinkulierung_Type" minOccurs="0"/>
+					<!--Element Vinkulierung ist deprecated, nutze neueres Konzept Sicherstellung -->
+					<xsd:element name="Bezugsrecht" type="cst:Bezugsrecht_Type" minOccurs="0"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Eingeschraenkt" type="xsd:boolean" default="0" minOccurs="0"/>
+					<xsd:element name="Neuwertklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TeilkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Teilkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Vandalismusklausel" type="xsd:boolean"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VollkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Vollkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Leasingklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="InsassenUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Insassenunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="InsassenUnfallSystem" type="InsassenUnfallSystem_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LenkerUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Lenkerunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AssistanceKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Assistance</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfzRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Kfz-Rechtsschutz-Versicherung, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkehrsrechtsschutz" type="VerkehrsrechtsschutzKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VerkehrsrechtsschutzKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Verkehrsrechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Typen für die BOA-Services fuer Kfz -->
+	<xsd:complexType name="SpezBerechnungKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antragsanfrage und Antragsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+					<xsd:element name="BonusMalus" type="cst:BonusMalusSystem_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>BonusMalus beim Verband</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vinkulierung" type="cst:Vinkularglaeubiger_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vinkulierungsdaten (deprecated, verwende Sicherstellung)</xsd:documentation>
+						</xsd:annotation>
+						<!--deprecated, nutze neueres Konzept Sicherstellung -->
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheKfzDaten" type="ZusaetzlicheKfzdaten_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Deprecated, verwende analoge Elemente an Fahrzeug_Type</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<!-- deprecated, fuer zusaetzliche Angaben zum Fahrzeug sollten dem Element VersicherteFahrzeuge
+					(cst:Fahrzeug_Type) als Erweiterung von ZusaetzlicheRisikodaten_Type mitgegeben werden -->
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingKfzResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Alternativen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="UpsellingVerkaufsprodukte" type="VerkaufsproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Berechnung die Details der Berechnung.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ResponseUpselling" type="UpsellingKfzResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Request für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Response für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Erstellung eines Offerts.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="SpezOffertKfz_Type"/>
+							</xsd:complexContent>
+							<!-- Jens Buehring 16.9.2021: Dieser anonyme Innertype ist unnoetig und weicht vom Schema der anderen Requests ab. Aus Gruenden der Abwaertskompatibilitaet muss es aber bis zu einem Refactoring so stehen bleiben. -->
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional die Daten des Antrags, wenn nicht Bezug auf ein vorangegangenes SubmitApplication genommen wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Hier werden nochmals alle Antragsdaten zur Verfügung gestellt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Konkrete Services (Request- und Responseobjekte) Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="CalculateKfzRequest" type="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Kfz Berechnung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateKfzResponse" type="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzRequest" type="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Kfz Offert</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzResponse" type="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offert Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzRequest" type="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für einen Kfz Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzResponse" type="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antrag Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzRequest" type="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzResponse" type="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="FahrzeugRefLfdNr" type="xsd:unsignedShort">
+		<xsd:annotation>
+			<xsd:documentation>Referenziert auf ein versichertes Fahrzeug über die laufende Nummer innerhalb eines Elementarprodukts.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="VorversicherungenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorversicherungen, Implementierung speziell für Kfz. Alternativ siehe auch allgemeine spartenübergreifende Implementierung cst:VorversicherungenImpl_Type.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Vorversicherungen_Type">
+				<xsd:sequence>
+					<xsd:element name="VorversicherungKfz" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="cst:VorversicherungenDetail_Type">
+									<xsd:attribute name="VtgSparteCd" type="omds:VtgSparteCd_Type" use="optional"/>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="VorversicherungRechtsschutz" type="cst:VorversicherungenDetail_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="InsassenUnfallSystem_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type System Insassenunfallversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Pauschalsystem"/>
+			<xsd:enumeration value="Platzsystem1"/>
+			<xsd:enumeration value="Platzsystem2"/>
+			<xsd:enumeration value="Personensystem"/>
+			<xsd:enumeration value="Lenkerunfallversicherung"/>
+			<xsd:enumeration value="Aufsassenunfallversicherung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="VarianteLeihwagen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Variante Leihwagen (A, B)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="VA">
+				<xsd:annotation>
+					<xsd:documentation>ohne Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VB">
+				<xsd:annotation>
+					<xsd:documentation>mit Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Zusätzliche KFZ-Daten -->
+	<xsd:complexType name="ZusaetzlicheKfzdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zusätzliche Kfz-Daten; Deprecated, Elemente sind ab
+				Version 1.11 in Fahrzeug_Type enthalten.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="KfzKennzeichen">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="3"/>
+						<xsd:maxLength value="9"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="Fahrgestellnummer" type="Fahrgestellnummer_Type"/>
+			<xsd:element name="ErfolgtAnmeldungZeitgleichMitAbmeldung" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="AbmeldedatumWechselkennzeichenFahrzeug" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="Wechselkennzeichen" type="Wechselkennzeichen_Type" minOccurs="0"/>
+			<xsd:element name="Fahrzeugzustand" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Fahrzeugzustand als Schlüsselwerte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="FzZustandBesichtigung" type="FzZustandBesichtigung_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Detailierte Fahrzeugzustandsbeschreibung z.B. aus einer Besichtigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdatenKfz" type="ZusaetzlicheAntragsdatenKfz_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Wechselkennzeichen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardimplementierung von AWechselkennzeichen_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:AWechselkennzeichen_Type">
+				<xsd:sequence>
+					<xsd:element name="WechselkennzeichenArt">
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:enumeration value="Neues Fahrzeug als WKZ in bestehenden Vertrag einbündeln"/>
+								<xsd:enumeration value="Fahrzeugwechsel im bestehenden WKZ-Vertrag"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="BestehenderWechselkennzeichenvertrag" type="xsd:string"/>
+					<xsd:element name="ErsetztWirdFahrgestellnummer" type="Fahrgestellnummer_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="Fahrgestellnummer_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Fahrgestellnummer FIN</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="30"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="FzZustandBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardimplementierung des AFzZustandBesichtigung_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:AFzZustandBesichtigung_Type">
+				<xsd:sequence>
+					<xsd:element name="ZustandsberichtLiegtAlsFormularBei" type="xsd:boolean" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Zustandsbericht liegt als Formular bei bzw. Besichtigung durch externe Stelle veranlasst - muss dann als Attachment mitgeschickt werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ArtBesichtigung" type="ArtBesichtigung_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Art der Besichtigung bzw. Quelle der Zustandsbeschreibung</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SchaedenAnScheibenKleinglas" type="SchaedenAnScheibenKleinglas_Type" minOccurs="0"/>
+					<xsd:element name="SchaedenAmFahrzeug" type="SchaedenAmFahrzeug_Type" minOccurs="0"/>
+					<xsd:element name="KilometerLtBesichtigung" type="xsd:integer" minOccurs="0"/>
+					<xsd:element name="Vorschaeden" type="xsd:string" minOccurs="0"/>
+					<xsd:element name="Besichtigungsort" type="xsd:string" minOccurs="0"/>
+					<xsd:element name="Besichtigungsdatum" type="xsd:date" minOccurs="0"/>
+					<xsd:element name="GrundFuerNachbesichtigung" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="ArtBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Zustandsbeschreibung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Besichtigung durch Betreuer"/>
+			<xsd:enumeration value="Kaufvertrag Markenhaendler mit Beschreibung"/>
+			<xsd:enumeration value="Besichtigung durch ARBOE, OEAMTC"/>
+			<xsd:enumeration value="Nachbesichtigung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAnScheibenKleinglas_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Beschreibung Schäden an Kleinglas</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an Scheiben / Kleinglas"/>
+			<xsd:enumeration value="Schäden an Scheiben / Kleinglas"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAmFahrzeug_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Schäden am Fahrzeug</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an der Karosserie"/>
+			<xsd:enumeration value="Schäden an der Karosserie"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ZusaetzlicheAntragsdatenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ für VU-Spezifische Erweiterungen bei der Kfz-Beschreibung im Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:element name="CreateVBRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Versicherungsbestätigung zu generieren</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonRequest_Type">
+					<xsd:sequence>
+						<xsd:element name="Vermittlernr" type="omds:Vermnr" minOccurs="1">
+							<xsd:annotation>
+								<xsd:documentation>Vermittlernummer für welche die VB ausgestellt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Art">
+							<xsd:annotation>
+								<xsd:documentation>Neuanmeldung oder Wiederzulassung</xsd:documentation>
+							</xsd:annotation>
+							<xsd:simpleType>
+								<xsd:restriction base="xsd:string">
+									<xsd:enumeration value="NEU"/>
+									<xsd:enumeration value="WIEDER"/>
+								</xsd:restriction>
+							</xsd:simpleType>
+						</xsd:element>
+						<xsd:element name="Kennzeichen" type="omds:Pol_Kennz_Type" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Optional ein Kennzeichen, auf welches die VB beschränkt sein soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Polizzennr" type="omds:Polizzennr" minOccurs="0"/>
+						<xsd:element name="Fahrzeug" minOccurs="0" maxOccurs="3">
+							<xsd:annotation>
+								<xsd:documentation>Optional eine Liste von Fahrzeugen, auf deren Anmeldung die VB beschränkt sein soll.</xsd:documentation>
+							</xsd:annotation>
+							<xsd:complexType>
+								<xsd:sequence>
+									<xsd:element name="FzgArt" type="omds:FzgArtCd_Type"/>
+									<xsd:element name="MarkeType">
+										<xsd:simpleType>
+											<xsd:restriction base="xsd:string">
+												<xsd:maxLength value="20"/>
+											</xsd:restriction>
+										</xsd:simpleType>
+									</xsd:element>
+									<xsd:element name="Fahrgestnr" type="omds:Fahrgestnr_Type" minOccurs="0"/>
+								</xsd:sequence>
+							</xsd:complexType>
+						</xsd:element>
+						<xsd:element name="Versicherungsnehmer" type="cst:Person_Type">
+							<xsd:annotation>
+								<xsd:documentation>Spezifikation des Versicherungsnehmers</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="GueltigAb" type="omds:Datum" minOccurs="0"/>
+						<xsd:element name="VorlaeufigeDeckung" type="cst:VorlaeufigeDeckung_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Angaben zu gewünschten vorläufigen Deckungen (abseits von Haftpflicht)</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="ZusaetzlicheVBDaten" type="ZusaetzlicheVBDaten_Type" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Erweiterungsmöglichkeit für VU-spezifische Daten</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateVBResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response bei der Generierung einer Versicherungsbestätigung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="VBNr" type="xsd:string"/>
+						<xsd:element name="VBDokument" type="cst:ProzessDokHandout_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:complexType name="ZusaetzlicheVBDaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Erweiterungsmöglichkeit für Versicherungsbestaetigung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON2_Antrag_Kranken.xsd

@@ -0,0 +1,244 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-6-0.on2antrag.kranken" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-6-0.on2antrag.kranken" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VerkaufsproduktKranken_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Krankenversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Krankenprodukte" type="ProduktKranken_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste von Produkten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Möglichkeit Kranken-fremde Bausteine einzugliedern.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VersichertePersonen" type="cst:VersichertePerson_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Risikodaten der versicherten Personen (als versicherte Interessen), die im Produktbaum über die Lfnr referenziert werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Gruppe" type="xsd:string" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf eine Gruppe</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Kranken. Von diesem Typ können einzelne VUs ihre eigenen Produkte ableiten, wenn sie möchten.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktMitVp_Type">
+				<xsd:sequence>
+					<xsd:element name="Elementarprodukte" type="ElementarproduktKranken_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der Elementarprodukte</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Selbstbehalt über alle Elementarprodukte einheitlich.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Kranken. Von diesem Typ werden etwaige unternehmesspezifische Deckungen oder potentielle Standard-Deckungen abgeleitet.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKranken_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Offert-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKranken_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Antrags-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKranken_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Elemente für die Methoden -->
+	<xsd:element name="CalculateKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Requestobjekts für eine Berechnung Kranken</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CalculateRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CalculateKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Responseobjekts für eine Kranken-Berechnung</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CalculateResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsantwort" type="SpezBerechnungKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Kranken-Offerts</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateOfferRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertanfrage" type="SpezOffertKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Kranken-Offerts</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateOfferResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertantwort" type="SpezOffertKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Requestobjekts für die Erstellung eines Krankenantrags</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntragKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Responseobjekts für die Erstellung eines Krankenantrags</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntragKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKrankenRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntragKranken_Type" minOccurs="0"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKrankenResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntragKranken_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON2_Antrag_Leben.xsd

@@ -0,0 +1,335 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-5-0.on2antrag.leben" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-5-0.on2antrag.leben" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VerkaufsproduktLeben_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Leben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="LebenProdukte" type="ProduktLeben_Type" maxOccurs="unbounded"/>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Möglichkeit Zusatzprodukte anderer Sparten einzugliedern</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VersichertePersonen" type="cst:VersichertePerson_Type" minOccurs="1" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Risikoeigenschaften der versicherten Personen, die im Produktbaum referenziert werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Leben.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktMitVp_Type">
+				<xsd:sequence>
+					<xsd:element name="Tarife" type="TarifLeben_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der Tarife</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TarifLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Leben.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="GarantierteAblebenssumme" type="VersicherungssummeZusatzbaustein_Type" minOccurs="0"/>
+					<xsd:element name="Rentenoption" type="Rentenoption_Type" minOccurs="0"/>
+					<xsd:element name="Fondsauswahl" type="cst:ElementFondsauswahl_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Bei fondsgebundenen Produkten die Vorgabe der gewünschten Fonds.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zusatzbausteine" type="ZusatzversicherungLeben_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste von Zusatzbausteinen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Zusatzversicherung in der Sparte Leben (unterhalb von Elementarprodukt)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ZusatzproduktGenerisch_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Spezielle vorgefertigte Typen-->
+	<xsd:complexType name="ZusatzversicherungBerufsunfaehigkeit_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung Berufsunfähigkeit</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Wartefrist" type="Wartefrist_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungErwerbsunfaehigkeit_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung Erwerbsunfähigkeit</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Wartefrist" type="Wartefrist_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungPraemienuebernahmeAbleben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Praemienuebernahme im Ablebensfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Wartefrist" type="Wartefrist_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungUnfalltod_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung bei Unfalltod</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Versicherungssumme" type="VersicherungssummeZusatzbaustein_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzversicherungUnfallinvaliditaet_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Zusatzversicherung bei Unfallinvaliditaet</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzversicherungLeben_Type">
+				<xsd:sequence>
+					<xsd:element name="Versicherungssumme" type="VersicherungssummeZusatzbaustein_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ um Zusatzprodukte (Ebene Produkt) im Verkausfprodukt Leben zu definieren</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="Rentenoption_Type">
+		<xsd:annotation>
+			<xsd:documentation>Vorgefertigter Typ für eine Rentenoption</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="Wartefrist_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Element zur Abbildung einer Wartefrist</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="VersicherungssummeZusatzbaustein_Type">
+		<xsd:annotation>
+			<xsd:documentation>Definition einer Versicherungssumme in einem Zusatzbaustein</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="ProzentVersicherungssumme" type="cst:AttributDouble_Type" minOccurs="0"/>
+			<xsd:element name="Betrag" type="cst:AttributDezimal_Type" minOccurs="0"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Offert-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragLeben_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Antrags-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntragPersonen_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen und Elemente für die Methoden -->
+	<xsd:complexType name="CalculateLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Leben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Leben-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungLeben_Type"/>
+					<xsd:element name="Upsellingvarianten" type="SpezBerechnungLeben_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Leben-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Leben-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="SpezOffertLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requestobjekts für die Erstellung eines Leben-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für die Erstellung eines Leben-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragLeben_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragLeben_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateLebenRequest" type="CalculateLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateLebenResponse" type="CalculateLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferLebenRequest" type="CreateOfferLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferLebenResponse" type="CreateOfferLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationLebenRequest" type="CreateApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationLebenResponse" type="CreateApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationLebenRequest" type="SubmitApplicationLebenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationLebenResponse" type="SubmitApplicationLebenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung Leben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON2_Antrag_SachPrivat.xsd

@@ -0,0 +1,683 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VersichertesObjektSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type für ein versichertes Objekt in der Sach-Privat-Versicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="ObjektId" type="cst:ObjektId_Type" minOccurs="0"/>
+					<xsd:element name="RisikoAdresse" type="RisikoAdresse_Type"/>
+					<xsd:element name="RisikoGebaeude" type="RisikoGebaeude_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="RisikoHaushalt" type="RisikoHaushalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoAdresse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Beschreibung einer Risikoadresse</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="omds:ADRESSE_Type">
+				<xsd:sequence>
+					<xsd:element name="Horazone" type="xsd:unsignedByte" minOccurs="0"/>
+					<xsd:element name="ImVerbautenOrt" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="AusserhalbDesOrtsgebiets" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="ErreichbarkeitFuerLoeschfahrzeuge" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Tarifzone" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoHaushalt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Risikobeschreibung Haushalt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="Wohnflaeche" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Wohnfläche in qm</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AusstattungCd" type="omds:AusstattungCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>zweckmäßig, standard, gehoben...</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="NutzungCd" type="omds:NutzungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>ständig bewohnt, nicht-ständig bewohnt, unbewohnt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheHaushaltDaten" type="ZusaetzlicheHaushaltsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Erweiterungsmöglichkeit für weitere benötigte Daten, die nicht im Standard enthalten sind.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoGebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Risikobeschreibung Gebäude</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="GebaeudeArtCd" type="omds:GebaeudeArtCd_Type"/>
+					<xsd:element name="GebaeudeBez" type="xsd:string"/>
+					<xsd:element name="NutzungCd" type="omds:NutzungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>ständig bewohnt, nicht-ständig bewohnt, unbewohnt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BauartCd" type="omds:BauartCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Fertigteil, massiv, Holz...</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DachungCd" type="omds:DachungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>hart, nicht-hart</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GebaeudeHoeheCd" type="omds:GebaeudeHoeheCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Ebenerdig, 1 Stockwerk, 2 Stockwerke oder mehr als 2 Stockwerke</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BaujahrGebaeude" type="xsd:integer" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Jahreszahl</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="EL-Flaeche" type="omds:EL-Flaeche_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<!-- EL-Flaeche aus OMDS 2.10 -->
+					<xsd:element name="Vorschaeden" type="RisikoVorschaeden_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>wenn Vorschäden vorhanden sind, Typ des Schadens definieren</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AusstattungCd" type="omds:AusstattungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>zweckmäßig, standard, gehoben... (bei Gebäude oder nur in Haushalt?)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SichergKz" type="omds:Entsch2_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eigentumsrechte einer Bank ja / nein</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PreisProQm" type="omds:decimal" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Gebäude oder doch Ausstattung?</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheGebaeudedaten" type="ZusaetzlicheGebaeudedaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Erweiterungsmöglichkeit für weitere benötigte Daten, die nicht im Standard enthalten sind.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheHaushaltsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp zur Definition zusätzlicher Haushaltsdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp zur Definition zusätzlicher Gebäudedaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenWintergarten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Wintergarten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenSolarthermie_Type">
+		<xsd:annotation>
+			<xsd:documentation>Strandardbaustein Solarthermie</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenSchwimmbad_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Schwimmbad</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenPhotovoltaik_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Photovoltaik als Erweiterung von ZusaetzlicheGebaeudeDaten_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="RisikoVorschaeden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurden die Gebäude/der Wohnungsinhalt/Keller in den letzten 7 Jahren durch Hochwasser, Überschwemmung, Muren oder Lawinen beschädigt?</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Vorschaeden"/>
+			<xsd:enumeration value="ein Vorschaden"/>
+			<xsd:enumeration value="mehr als ein Vorschaden"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="Nebengebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für Nebengebäude</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Abstellgebaeude"/>
+			<xsd:enumeration value="Badehütte"/>
+			<xsd:enumeration value="Bootshaus"/>
+			<xsd:enumeration value="Carport"/>
+			<xsd:enumeration value="ehemaliges Wirtschaftsgebaeude"/>
+			<xsd:enumeration value="Garage"/>
+			<xsd:enumeration value="Gartenhaus (nicht für Wohnzwecke)"/>
+			<xsd:enumeration value="Holzhütte"/>
+			<xsd:enumeration value="Keller"/>
+			<xsd:enumeration value="Mobilheim (stationaer)"/>
+			<xsd:enumeration value="Nebengebaeude"/>
+			<xsd:enumeration value="Nebengebaeude mit Garage"/>
+			<xsd:enumeration value="Presshaus"/>
+			<xsd:enumeration value="Sauna"/>
+			<xsd:enumeration value="Scheune / Schuppen / Stadel"/>
+			<xsd:enumeration value="Werkstaette"/>
+			<xsd:enumeration value="Werkzeug- und Geraeteschuppen"/>
+			<xsd:enumeration value="Wintergarten, Veranda"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="VerkaufsproduktSachPrivat_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Besitz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Produkte" type="ProduktSachPrivat_Type" maxOccurs="unbounded"/>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteObjekte" type="cst:VersichertesInteresse_Type" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurzelelement für Sach-Privat-Produkte, auf welchem alle Sach-Privat Produkte aufbauen sollen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersObjekteRefLfnr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<!--					<xsd:element name="Elementarprodukte" type="ElementarproduktSachPrivat_Type" minOccurs="0" maxOccurs="unbounded"/>
+Jens Buehring entfernt 2.6.2020 weil die Untertypen spezifischere Listen haben (fuer Gebaeude und Haushalt) und wenn man selbst ein
+Unterobjekt definiert, sollte man seine eigene spezifische Loesung verwenden.
+-->
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="ProduktGebaeudeversicherung" type="ProduktGebaeudeversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischeres Element für Gebäudeversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="ProduktHaushaltsversicherung" type="ProduktHaushaltsversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischeres Element für Gebäudeinhaltversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ProduktGebaeudeversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für Gebaeudeversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ProduktSachPrivat_Type">
+				<xsd:sequence>
+					<xsd:element name="Deckungen" type="ElementarproduktGebaeude_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktHaushaltsversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für Gebäudeinhaltversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ProduktSachPrivat_Type">
+				<xsd:sequence>
+					<xsd:element name="Deckungen" type="ElementarproduktHaushalt_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurzelelement für Sach-Privat-Elementarprodukte, auf welchem alle Sach-Privat Elementarprodukte aufbauen sollen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersObjekteRefLfnr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Pauschalbetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+					<xsd:element name="Unterversicherungsverzicht" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="ProzentVersicherungssumme" type="xsd:unsignedShort" minOccurs="0"/>
+					<xsd:element name="Nebenkosten" type="cst:KostenFixOderProzent_Type" minOccurs="0"/>
+					<xsd:element name="Vorsorge" type="cst:KostenFixOderProzent_Type" minOccurs="0"/>
+					<xsd:element name="Hoechsthaftungssumme" type="omds:decimal" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktGebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für ein Gebäude-Elementarprodukt für einen Ansatz, in dem mit Vererbung für die einzelnen Sparten gearbeitet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktSachPrivat_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktHaushalt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für ein Gebäudeinhalts-Elementarprodukt für einen Ansatz, in dem mit Vererbung für die einzelnen Sparten gearbeitet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktSachPrivat_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GenElementarproduktGebaeude_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Elementarprodukt Gebäudeversicherung für einen Ansatz, in dem nicht mit Vererbung gearbeitet wird.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktGebaeude_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="GebaeudeSpartenCd_Type" minOccurs="1"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GenElementarproduktHaushalt_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Elementarprodukt Gebäudeinhaltsversicherung für einen Ansatz, in dem nicht mit Vererbung gearbeitet wird.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktHaushalt_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="HaushaltSpartenCd_Type" minOccurs="1"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="GebaeudeSpartenCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Basiert auf den Werten des SpartenCd_Type, diese Liste ist nur eingeschränkt auf die möglichen Gebäude Sparten Werte dürfen nur nach Aufnahme in den Basis-Typ hinzugefügt werden.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="999">
+				<xsd:annotation>
+					<xsd:documentation>sonstige</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="AS">
+				<xsd:annotation>
+					<xsd:documentation>Assistance</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="BU">
+				<xsd:annotation>
+					<xsd:documentation>Betriebs-Unterbrechung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ED">
+				<xsd:annotation>
+					<xsd:documentation>Einbruchdiebstahl</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="FE">
+				<xsd:annotation>
+					<xsd:documentation>Feuer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="GB">
+				<xsd:annotation>
+					<xsd:documentation>Glasbruch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HP">
+				<xsd:annotation>
+					<xsd:documentation>Haftpflicht</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="LW">
+				<xsd:annotation>
+					<xsd:documentation>Leitungswasser</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="MG">
+				<xsd:annotation>
+					<xsd:documentation>Maschinen und Geräte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="SS">
+				<xsd:annotation>
+					<xsd:documentation>Sonstige SV</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ST">
+				<xsd:annotation>
+					<xsd:documentation>Sturm</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="TI">
+				<xsd:annotation>
+					<xsd:documentation>Tierversicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="HaushaltSpartenCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Basiert auf den Werten des SpartenCd_Type, diese Liste ist nur eingeschränkt auf die möglichen Haushalt Sparten Werte dürfen nur nach Aufnahme in den Basis-Typ hinzugefügt werden.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="999">
+				<xsd:annotation>
+					<xsd:documentation>sonstige</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="AS">
+				<xsd:annotation>
+					<xsd:documentation>Assistance</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="BU">
+				<xsd:annotation>
+					<xsd:documentation>Betriebs-Unterbrechung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ED">
+				<xsd:annotation>
+					<xsd:documentation>Einbruchdiebstahl</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="EK">
+				<xsd:annotation>
+					<xsd:documentation>Elektronik</xsd:documentation>
+				</xsd:annotation>
+				<!-- deprecated, verwende EP -->
+			</xsd:enumeration>
+			<xsd:enumeration value="EP">
+				<xsd:annotation>
+					<xsd:documentation>Elektronik pauschal</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="FE">
+				<xsd:annotation>
+					<xsd:documentation>Feuer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="GB">
+				<xsd:annotation>
+					<xsd:documentation>Glasbruch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HH">
+				<xsd:annotation>
+					<xsd:documentation>Haushalt bzw. Wohnungs-Versicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HP">
+				<xsd:annotation>
+					<xsd:documentation>Haftpflicht</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="LW">
+				<xsd:annotation>
+					<xsd:documentation>Leitungswasser</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="MG">
+				<xsd:annotation>
+					<xsd:documentation>Maschinen und Geräte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="SS">
+				<xsd:annotation>
+					<xsd:documentation>Sonstige SV</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ST">
+				<xsd:annotation>
+					<xsd:documentation>Sturm</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="TI">
+				<xsd:annotation>
+					<xsd:documentation>Tierversicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!--Typen für die BOA-Services fuer Besitz -->
+	<xsd:complexType name="BerechnungSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="OffertSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AntragSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antraganfrage und Antragantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="BerechnungSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="BerechnungSachPrivat_Type"/>
+					<xsd:element name="ResponseUpselling" type="UpsellingSachPrivatResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für ein Offert Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="OffertSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für ein Offert Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="OffertSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für einen Antrag Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für einen Antrag Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="AntragSachPrivat_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateSachPrivatRequest" type="CalculateSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateSachPrivatResponse" type="CalculateSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferSachPrivatRequest" type="CreateOfferSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Offerterzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferSachPrivatResponse" type="CreateOfferSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offerterzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationSachPrivatRequest" type="CreateApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Antragserzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationSachPrivatResponse" type="CreateApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antragserzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationSachPrivatRequest" type="SubmitApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Antragseinreichung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationSachPrivatResponse" type="SubmitApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antragseinreichung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_11_0/omds3_ON2_Antrag_Unfall.xsd

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.unfall" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.unfall" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.11.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds216-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VerkaufsproduktUnfall_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Unfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Unfallprodukte" type="ProduktUnfall_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste von Produktbausteinen der Ebene 2, Produktbausteine von der Klasse "Versicherte Person"</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Möglichkeit Unfall-fremde Bausteine einzugliedern, z.B. Produkte aus Sach-Privat.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VersichertePersonen" type="cst:VersichertePerson_Type" minOccurs="1" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Risikodaten der versicherten Personen. Diese werden im Produktbaum auf Ebene 2 referenziert.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Unfall. Von diesem Typ können einzelne VUs ihre eigenen Produkte ableiten, wenn sie möchten.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktMitVp_Type">
+				<xsd:sequence>
+					<xsd:element name="Leistungsarten" type="LeistungsartUnfall_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der Elementarprodukte</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Selbstbehalt über alle Elementarprodukte einheitlich.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LeistungsartUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Unfall. Von diesem Typ werden etwaige unternehmesspezifische Deckungen oder potentielle Standard-Deckungen abgeleitet.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Offert-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Antrags-Erzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen und Elemente für die Methoden -->
+	<xsd:complexType name="CalculateUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Unfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Unfall-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungUnfall_Type"/>
+					<xsd:element name="Upsellingvarianten" type="SpezBerechnungUnfall_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Unfall-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Unfall-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="SpezOffertUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requestobjekts für die Erstellung eines Unfallantrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Responseobjekts für die Erstellung eines Unfallantrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="SpezAntragUnfall_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="SpezAntragUnfall_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateUnfallRequest" type="CalculateUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateUnfallResponse" type="CalculateUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferUnfallRequest" type="CreateOfferUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferUnfallResponse" type="CreateOfferUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationUnfallRequest" type="CreateApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationUnfallResponse" type="CreateApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationUnfallRequest" type="SubmitApplicationUnfallRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationUnfallResponse" type="SubmitApplicationUnfallResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung Unfall</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_1_1/omds3CommonServiceTypes.xsd

@@ -0,0 +1,307 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3CommonServiceTypes-1-1-0" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" targetNamespace="urn:omds3CommonServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.1.1">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<!-- Elemente, die von allen Services gemeinsam verwendet werden -->
+	<xsd:element name="serviceFault" type="ServiceFault">
+		<xsd:annotation>
+			<xsd:documentation>Fault-Element, wie es von einer Soap-Operation im Falle eines Faults geworfen wird</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ServiceFault">
+		<xsd:annotation>
+			<xsd:documentation>Enthält eventuelle Fehlermeldungen + Fehlercode + Fehlertyp.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="errorType">
+				<xsd:annotation>
+					<xsd:documentation>Fehlertyp ( 1 = Fehler, 2 = Warnung, 3 = Hinweis)
+                    </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:integer">
+						<xsd:pattern value="1">
+							<xsd:annotation>
+								<xsd:documentation>Fehler</xsd:documentation>
+							</xsd:annotation>
+						</xsd:pattern>
+						<xsd:pattern value="2">
+							<xsd:annotation>
+								<xsd:documentation>Warnung</xsd:documentation>
+							</xsd:annotation>
+						</xsd:pattern>
+						<xsd:pattern value="3">
+							<xsd:annotation>
+								<xsd:documentation>Hinweis</xsd:documentation>
+							</xsd:annotation>
+						</xsd:pattern>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="errorCode" type="xsd:integer">
+				<xsd:annotation>
+					<xsd:documentation>Fehlercode entsprechend allgemeiner Fehlerliste
+                    </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="errorMsg" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Eine ausgeschriebene Fehlermeldung, für den User</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="GeschaeftsfallId_Type">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ einer GeschaeftsfallId</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string"/>
+	</xsd:simpleType>
+	<xsd:element name="GeschaeftsfallId" type="GeschaeftsfallId_Type">
+		<xsd:annotation>
+			<xsd:documentation>Eine GeschäftsfallId als String</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:simpleType name="OMDSVersion_Type">
+		<xsd:annotation>
+			<xsd:documentation>Die OMDS-Version als String</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:maxLength value="20"/>
+			<xsd:enumeration value="OMDS-Services 1.0.0"/>
+			<xsd:enumeration value="OMDS-Services 1.1.0"/>
+			<xsd:enumeration value="OMDS-Services 1.1.1"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="AuthorizationFilter" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen abstrakten Filter um bestimmte spezifische Elemente herauszufiltern</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="AgentFilter_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ein spezieller AuthorizationFilterType, der eine Anfrage dahingehend einschränkt, dass nur Ergebnisse für eine bestimmte MaklerID oder Vermnr (Vermittlernummer) zurück gegeben werden</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AuthorizationFilter">
+				<xsd:choice>
+					<xsd:element name="MaklerID" type="MaklerID_Type">
+						<xsd:annotation>
+							<xsd:documentation>Entspricht der MaklerID in der OMDS-Datensatzdefinition. Die MaklerID ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für das jeweilige VU, bei welchem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die MaklerID mit der Vermittlernummer (Vermnr) zusammenfällt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vermnr" type="omds:Vermnr" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Vermittlernummer vom Typ Vermnr aus der OMDS-Datensatz Definition. Die Vermittlernummer wird als Filterparameter verwendet, um eine Anfrage auf eine bestimmte Vermittlernummer zu beschränken, wenn der Benutzer auf mehrere Vermittlernummern berechtigt ist.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:choice>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="MaklerID_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine MaklerID als String mit mindestens einem und max. 26 Zeichen. Diese Typ-Definition entspricht der Definition des Attributs MaklerID im OMDS-Datensatz, in dem es aber keinen unabhaengigen, referenzierbaren Typ gibt.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="26"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ElementIdType">
+		<xsd:annotation>
+			<xsd:documentation>Ein Typ für eine Objekt-Id in Verbindung mit einem möglichen Ablaufzeitpunkt und dem Hinweis, ob die Id nur einmalig oder auch mehrmalig verwendet werden kann</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="id" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Elements als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="idValidUntil" type="xsd:dateTime">
+				<xsd:annotation>
+					<xsd:documentation>Die Gültigkeit der Id des Elements. Wenn die Gültigkeit "null", 
+					ist die Id unbegrenzt gueltig. Von der geplanten Gültigkeit unabhängig kann das 
+					Element dennoch aus anderen Gründen gelöscht werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="idIsSingleUse" type="xsd:boolean">
+				<xsd:annotation>
+					<xsd:documentation>wahr wenn die Id nur einmal verwendet werden kann, sonst falsch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="DocumentType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert die unterschiedlichen Dokumententypen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:int">
+			<xsd:minInclusive value="0"/>
+			<xsd:maxInclusive value="26"/>
+			<xsd:enumeration value="0">
+				<xsd:annotation>
+					<xsd:documentation>Sonstiges</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="1">
+				<xsd:annotation>
+					<xsd:documentation>Antrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="2">
+				<xsd:annotation>
+					<xsd:documentation>Deckungsbestätigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="3">
+				<xsd:annotation>
+					<xsd:documentation>Erstpolizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="4">
+				<xsd:annotation>
+					<xsd:documentation>Folgepolizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="5">
+				<xsd:annotation>
+					<xsd:documentation>Zusatzvereinbarungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="6">
+				<xsd:annotation>
+					<xsd:documentation>Vinkulierungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="7">
+				<xsd:annotation>
+					<xsd:documentation>Bewertungsgutachten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="8">
+				<xsd:annotation>
+					<xsd:documentation>Verständigung Gewinnbeteiligungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="9">
+				<xsd:annotation>
+					<xsd:documentation>Umsatz/Lohnsummenmeldung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="10">
+				<xsd:annotation>
+					<xsd:documentation>Umsatz/Lohnsummenabrechnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="11">
+				<xsd:annotation>
+					<xsd:documentation>BU-Summenmeldung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="12">
+				<xsd:annotation>
+					<xsd:documentation>BU-Summenabrechnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="13">
+				<xsd:annotation>
+					<xsd:documentation>Finanzamtsbestätigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="14">
+				<xsd:annotation>
+					<xsd:documentation>Kündigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="15">
+				<xsd:annotation>
+					<xsd:documentation>Stornopolizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="16">
+				<xsd:annotation>
+					<xsd:documentation>Schadenmeldung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="17">
+				<xsd:annotation>
+					<xsd:documentation>Schadennachtrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="18">
+				<xsd:annotation>
+					<xsd:documentation>Gutachten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="19">
+				<xsd:annotation>
+					<xsd:documentation>Behördliche Anzeigebestätigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="20">
+				<xsd:annotation>
+					<xsd:documentation>Kostenvoranschlag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="21">
+				<xsd:annotation>
+					<xsd:documentation>Rechnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="22">
+				<xsd:annotation>
+					<xsd:documentation>Schadenablehnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="23">
+				<xsd:annotation>
+					<xsd:documentation>Schadenfoto</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="24">
+				<xsd:annotation>
+					<xsd:documentation>Abfindungserklärung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="25">
+				<xsd:annotation>
+					<xsd:documentation>Restwertangebot</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="26">
+				<xsd:annotation>
+					<xsd:documentation>Schreiben Rechtsanwalt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<!-- Dokumententypen Schaden -->
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="PartnerRoleType">
+		<xsd:annotation>
+			<xsd:documentation>Definition der Partnerrollen über jeweils 2 Buchstaben. Typ wurde angelehnt an VtgRolleCd_Type, allerdings wurde neuer Typ benötigt, da Versicherte Person als Partnerrolle relevant ist.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:length value="2"/>
+			<xsd:enumeration value="VN">
+				<xsd:annotation>
+					<xsd:documentation>Versicherungsnehmer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VP">
+				<xsd:annotation>
+					<xsd:documentation>Versicherte Person</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:element name="OrdnungsbegriffZuordFremd">
+		<xsd:annotation>
+			<xsd:documentation>Ein Ordnungsbegriff aus einem Fremdsystem, welcher dabei hilft die Kommunikation zwischen zwei Systemen zu vereinfachen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:simpleType>
+			<xsd:restriction base="xsd:string">
+				<xsd:maxLength value="255"/>
+			</xsd:restriction>
+		</xsd:simpleType>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_1_1/omds3ExampleVuServiceTypes.xsd

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:omds="urn:omds20" xmlns:ost="urn:omds3ServiceTypes-1-1-0" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="urn:exampleVuServiceTypes" targetNamespace="urn:exampleVuServiceTypes" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.1.1">
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<!-- Beispiel fuer die Erweiterung eines Typs fuer die speziellen Belange einer VU  -->
+	<xsd:complexType name="UserDataResponseExampleVU">
+		<xsd:complexContent>
+			<xsd:extension base="ost:UserDataResponse">
+				<xsd:sequence>
+					<xsd:element name="role" type="xsd:string"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_1_1/omds3Services.wsdl

@@ -0,0 +1,629 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- version="1.1.1" -->
+<definitions 
+	name="omds3Services-1-1-0" 
+	xmlns:os="urn:omds3Services-1-1-0"
+	targetNamespace="urn:omds3Services-1-1-0"
+	xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" 
+	xmlns:ost="urn:omds3ServiceTypes-1-1-0" 
+	xmlns="http://schemas.xmlsoap.org/wsdl/"
+	xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" 
+	xmlns:ns="http://www.w3.org/2001/XMLSchema"
+	xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/" 
+	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+>
+	
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd" />
+		</schema>
+	</types>
+
+	<message name="loginRequest">
+		<part name="parameters" element="ost:loginRequest"/>
+	</message>
+	<message name="loginResponse">
+		<part name="parameters" element="ost:loginResponse"/>
+	</message>
+
+
+	<message name="getUserDataRequest">
+		<part name="parameters" element="ost:getUserDataRequest"/>
+	</message>
+	<message name="getUserDataResponse">
+		<part name="parameters" element="ost:getUserDataResponse"/>
+	</message>
+
+	
+	<message name="getOMDSPackageListRequest">
+		<part name="parameters" element="ost:getOMDSPackageListRequest"/>
+	</message>
+	<message name="getOMDSPackageListResponse">
+		<part name="parameters" element="ost:getOMDSPackageListResponse" />
+	</message>
+
+
+	<message name="getOMDSPackageRequest">
+		<part name="parameters" element="ost:getOMDSPackageRequest"/>
+	</message>
+	<message name="getOMDSPackageResponse">
+		<part name="parameters" element="ost:getOMDSPackageResponse" />
+	</message>
+	
+	<!-- Vertragsbezogene Dokumente -->
+	
+	<message name="getArcImageInfosRequest">
+		<part name="parameters" element="ost:getArcImageInfosRequest"/>
+	</message>
+	<message name="getArcImageInfosResponse">
+		<part name="parameters" element="ost:getArcImageInfosResponse" />
+	</message>
+	<message name="getArcImageRequest">
+		<part name="parameters" element="ost:getArcImageRequest"/>
+	</message>
+	<message name="getArcImageResponse">
+		<part name="parameters" element="ost:getArcImageResponse" />
+	</message>
+	
+	<!-- Deep Links -->
+	
+	<message name="deepLinkClaimRequest">
+		<part name="parameters" element="ost:getDeepLinkClaimRequest"/>
+	</message>
+	<message name="deepLinkClaimResponse">
+		<part name="parameters" element="ost:getDeepLinkClaimResponse" />
+	</message>
+	
+	<message name="deepLinkPartnerRequest">
+		<part name="parameters" element="ost:getDeepLinkPartnerRequest"/>
+	</message>
+	<message name="deepLinkPartnerResponse">
+		<part name="parameters" element="ost:getDeepLinkPartnerResponse" />
+	</message>
+	<message name="deepLinkOfferRequest">
+		<part name="parameters" element="ost:getDeepLinkOfferRequest"/>
+	</message>
+	<message name="deepLinkOfferResponse">
+		<part name="parameters" element="ost:getDeepLinkOfferResponse" />
+	</message>
+	<message name="deepLinkPolicyRequest">
+		<part name="parameters" element="ost:getDeepLinkPolicyRequest"/>
+	</message>
+	<message name="deepLinkPolicyResponse">
+		<part name="parameters" element="ost:getDeepLinkPolicyResponse" />
+	</message>
+	<!-- Schaden -->
+	<message name="CreateClaimRequestMsg">
+		<part name="parameters" element="ost:CreateClaimRequest"/>
+	</message>
+	<message name="CreateClaimResponseMsg">
+		<part name="parameters" element="ost:CreateClaimResponse" />
+	</message>
+	
+	<message name="InitiateClaimRequestMsg">
+		<part name="parameters" element="ost:InitiateClaimRequest"/>
+	</message>
+	<message name="InitiateClaimResponseMsg">
+		<part name="parameters" element="ost:InitiateClaimResponse" />
+	</message>
+	
+	
+	<message name="AddDocToClaimRequestMsg">
+		<part name="parameters" element="ost:AddDocToClaimRequest"/>
+	</message>
+	<message name="AddDocToClaimResponseMsg">
+		<part name="parameters" element="ost:AddDocToClaimResponse" />
+	</message>
+		
+	<message name="GetClaimRequestMsg">
+		<part name="parameters" element="ost:GetClaimRequest"/>
+	</message>
+	<message name="GetClaimResponseMsg">
+		<part name="parameters" element="ost:GetClaimResponse" />
+	</message>	
+	<message name="GetClaimLightRequestMsg">
+		<part name="parameters" element="ost:GetClaimLightRequest"/>
+	</message>
+	<message name="GetClaimLightResponseMsg">
+		<part name="parameters" element="ost:GetClaimLightResponse" />
+	</message>	
+	<message name="GetNumberOfDocumentsRequestMsg">
+		<part name="parameters" element="ost:GetNumberOfDocumentsRequest"/>
+	</message>
+	<message name="GetNumberOfDocumentsResponseMsg">
+		<part name="parameters" element="ost:GetNumberOfDocumentsResponse" />
+	</message>	
+	<message name="GetDocumentInfosRequestMsg">
+		<part name="parameters" element="ost:GetDocumentInfosRequest"/>
+	</message>
+	<message name="GetDocumentInfosResponseMsg">
+		<part name="parameters" element="ost:GetDocumentInfosResponse" />
+	</message>	
+	<message name="SearchClaimRequestMsg">
+		<part name="parameters" element="ost:SearchClaimRequest"/>
+	</message>
+	<message name="SearchClaimResponseMsg">
+		<part name="parameters" element="ost:SearchClaimResponse" />
+	</message>		
+	
+	<message name="GetLossEventListRequestMsg">
+		<part name="parameters" element="ost:LossEventListRequest"/>
+	</message>
+	<message name="GetLossEventListResponseMsg">
+		<part name="parameters" element="ost:LossEventListResponse" />
+	</message>		
+	<message name="GetChangedClaimsListRequestMsg">
+		<part name="parameters" element="ost:ChangedClaimsListRequest"/>
+	</message>
+	<message name="GetChangedClaimsListResponseMsg">
+		<part name="parameters" element="ost:ChangedClaimsListResponse" />
+	</message>		
+	
+	
+	<message name="DeclareEndpointRequestMsg">
+		<part name="parameters" element="ost:DeclareEndpointRequest"/>
+	</message>
+	<message name="DeclareEndpointResponseMsg">
+		<part name="parameters" element="ost:DeclareEndpointResponse" />
+	</message>	
+	
+	
+	<!-- Fehler -->	
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+	
+	
+	<portType name="omdsServicePortType">
+
+		<operation name="login">
+			<input name="loginRequest" message="os:loginRequest" />
+			<output name="loginResponse" message="os:loginResponse" />
+            <fault name="loginFault" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="getUserData">
+			<input name="getUserDataRequest" message="os:getUserDataRequest" />
+			<output name="getUserDataResponse" message="os:getUserDataResponse" />
+			<fault name="getUserDataFault" message="os:ServiceFaultMsg" />
+		</operation>
+	
+		<operation name="getOMDSPackageList">
+			<input name="getOMDSPackageListRequest" message="os:getOMDSPackageListRequest" />
+			<output name="getOMDSPackageListResponse" message="os:getOMDSPackageListResponse" />
+			<fault name="getOMDSPackageListFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<input name="getOMDSPackageRequest" message="os:getOMDSPackageRequest" />
+			<output name="getOMDSPackageResponse" message="os:getOMDSPackageResponse" />
+			<fault name="getOMDSPackageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImageInfos">
+			<input name="getArcImageInfosRequest" message="os:getArcImageInfosRequest" />
+			<output name="getArcImageInfosResponse" message="os:getArcImageInfosResponse" />
+			<fault name="getArcImageInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImage">
+			<input name="getArcImageRequest" message="os:getArcImageRequest" />
+			<output name="getArcImageResponse" message="os:getArcImageResponse" />
+			<fault name="getArcImageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkClaim">
+			<input name="deepLinkClaimRequest" message="os:deepLinkClaimRequest" />
+			<output name="deepLinkClaimResponse" message="os:deepLinkClaimResponse" />
+			<fault name="deepLinkClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<input name="deepLinkPartnerRequest" message="os:deepLinkPartnerRequest" />
+			<output name="deepLinkPartnerResponse" message="os:deepLinkPartnerResponse" />
+			<fault name="deepLinkPartnerFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<input name="deepLinkOfferRequest" message="os:deepLinkOfferRequest" />
+			<output name="deepLinkOfferResponse" message="os:deepLinkOfferResponse" />
+			<fault name="deepLinkOfferFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<input name="deepLinkPolicyRequest" message="os:deepLinkPolicyRequest" />
+			<output name="deepLinkPolicyResponse" message="os:deepLinkPolicyResponse" />
+			<fault name="deepLinkPolicyFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="createClaim">
+			<input name="CreateClaimRequestPort" message="os:CreateClaimRequestMsg" />
+			<output name="CreateClaimResponsePort" message="os:CreateClaimResponseMsg" />
+			<fault name="CreateClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		
+		<operation name="initiateClaim">
+			<input name="InitiateClaimRequestPort" message="os:InitiateClaimRequestMsg" />
+			<output name="InitiateClaimResponsePort" message="os:InitiateClaimResponseMsg" />
+			<fault name="InitiateClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+	
+		<operation name="addDocToClaim">
+			<input name="AddDocToClaimRequestPort" message="os:AddDocToClaimRequestMsg" />
+			<output name="AddDocToClaimResponsePort" message="os:AddDocToClaimResponseMsg" />
+			<fault name="AddDocToClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaim">
+			<input name="GetClaimRequestPort" message="os:GetClaimRequestMsg" />
+			<output name="GetClaimResponsePort" message="os:GetClaimResponseMsg" />
+			<fault name="GetClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaimLight">
+			<input name="GetClaimLightRequestPort" message="os:GetClaimLightRequestMsg" />
+			<output name="GetClaimLightResponsePort" message="os:GetClaimLightResponseMsg" />
+			<fault name="GetClaimLightFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getNumberOfDocuments">
+			<input name="GetNumberOfDocumentsRequestPort" message="os:GetNumberOfDocumentsRequestMsg" />
+			<output name="GetNumberOfDocumentsResponsePort" message="os:GetNumberOfDocumentsResponseMsg" />
+			<fault name="GetNumberOfDocumentsFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentInfos">
+			<input name="GetDocumentInfosRequestPort" message="os:GetDocumentInfosRequestMsg" />
+			<output name="GetDocumentInfosResponsePort" message="os:GetDocumentInfosResponseMsg" />
+			<fault name="GetDocumentInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="searchClaim">
+			<input name="SearchClaimRequestPort" message="os:SearchClaimRequestMsg" />
+			<output name="SearchClaimResponsePort" message="os:SearchClaimResponseMsg" />
+			<fault name="SearchClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getLossEventList">
+			<input name="LossEventListRequestPort" message="os:GetLossEventListRequestMsg" />
+			<output name="LossEventListResponsePort" message="os:GetLossEventListResponseMsg" />
+			<fault name="LossEventListFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getChangedClaimsList">
+			<input name="ChangedClaimsListPort" message="os:GetChangedClaimsListRequestMsg" />
+			<output name="ChangedClaimsListResponsePort" message="os:GetChangedClaimsListResponseMsg" />
+			<fault name="ChangedClaimsListFault" message="os:ServiceFaultMsg" />
+		</operation>		
+		<operation name="declareEndpoint">
+			<input name="DeclareEndpointRequestPort" message="os:DeclareEndpointRequestMsg" />
+			<output name="DeclareEndpointResponsePort" message="os:DeclareEndpointResponseMsg" />
+			<fault name="DeclareEndpointFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+		
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+		
+		
+		<operation name="login">
+			<soap:operation soapAction="urn:login" style="document" />
+			<input name="loginRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="loginResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="loginFault">
+				<soap:fault name="loginFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getUserData">
+			<soap:operation soapAction="urn:getUserData" style="document" />
+			<input name="getUserDataRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getUserDataResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getUserDataFault">
+				<soap:fault name="getUserDataFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<soap:operation soapAction="urn:getOMDSPackageList" style="document" />
+			<input name="getOMDSPackageListRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageListResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageListFault">
+				<soap:fault name="getOMDSPackageListFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getOMDSPackage">
+			<soap:operation soapAction="urn:getOMDSPackage" style="document" />
+			<input name="getOMDSPackageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageFault">
+				<soap:fault name="getOMDSPackageFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<!-- Vertragsbezogene Dokumente ArcImage -->
+		
+		<operation name="getArcImageInfos">
+			<soap:operation soapAction="urn:getArcImageInfos" style="document" />
+			<input name="getArcImageInfosRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageInfosResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageInfosFault">
+				<soap:fault name="getArcImageInfosFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getArcImage">
+			<soap:operation soapAction="urn:getArcImage" style="document" />
+			<input name="getArcImageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageFault">
+				<soap:fault name="getArcImageFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<!-- Deep-Links -->
+		
+		<operation name="deepLinkClaim">
+			<soap:operation soapAction="urn:deepLinkClaim" style="document" />
+			<input name="deepLinkClaimRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkClaimResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkClaimFault">
+				<soap:fault name="deepLinkClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkPartner">
+			<soap:operation soapAction="urn:deepLinkPartner" style="document" />
+			<input name="deepLinkPartnerRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPartnerResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPartnerFault">
+				<soap:fault name="deepLinkPartnerFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkOffer">
+			<soap:operation soapAction="urn:deepLinkOffer" style="document" />
+			<input name="deepLinkOfferRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkOfferResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkOfferFault">
+				<soap:fault name="deepLinkOfferFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkPolicy">
+			<soap:operation soapAction="urn:deepLinkPolicy" style="document" />
+			<input name="deepLinkPolicyRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPolicyResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPolicyFault">
+				<soap:fault name="deepLinkPolicyFault" use="literal"/>
+			</fault>
+		</operation>
+	
+		<!-- Schaden -->
+		<operation name="createClaim">
+			<soap:operation soapAction="urn:createClaim" style="document" />
+			<input name="CreateClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="CreateClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="CreateClaimFault">
+				<soap:fault name="CreateClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="initiateClaim">
+			<soap:operation soapAction="urn:initiateClaim" style="document" />
+			<input name="InitiateClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="InitiateClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="InitiateClaimFault">
+				<soap:fault name="InitiateClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+
+		<operation name="addDocToClaim">
+			<soap:operation soapAction="urn:addDocToClaim" style="document" />
+			<input name="AddDocToClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="AddDocToClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="AddDocToClaimFault">
+				<soap:fault name="AddDocToClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getClaim">
+			<soap:operation soapAction="urn:getClaim" style="document" />
+			<input name="GetClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimFault">
+				<soap:fault name="GetClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getClaimLight">
+			<soap:operation soapAction="urn:getClaimLight" style="document" />
+			<input name="GetClaimLightRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimLightResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimLightFault">
+				<soap:fault name="GetClaimLightFault" use="literal"/>
+			</fault>
+		</operation>
+				
+		<operation name="getNumberOfDocuments">
+			<soap:operation soapAction="urn:getNumberOfDocuments" style="document" />
+			<input name="GetNumberOfDocumentsRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetNumberOfDocumentsResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetNumberOfDocumentsFault">
+				<soap:fault name="GetNumberOfDocumentsFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getDocumentInfos">
+			<soap:operation soapAction="urn:getDocumentInfos" style="document" />
+			<input name="GetDocumentInfosRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentInfosResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentInfosFault">
+				<soap:fault name="GetDocumentInfosFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="searchClaim">
+			<soap:operation soapAction="urn:searchClaim" style="document" />
+			<input name="SearchClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SearchClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SearchClaimFault">
+				<soap:fault name="SearchClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getLossEventList">
+			<soap:operation soapAction="urn:getLossEventList" style="document" />
+			<input name="LossEventListRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="LossEventListResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="LossEventListFault">
+				<soap:fault name="LossEventListFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getChangedClaimsList">
+			<soap:operation soapAction="urn:getChangedClaimsList" style="document" />
+			<input name="ChangedClaimsListPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="ChangedClaimsListResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="ChangedClaimsListFault">
+				<soap:fault name="ChangedClaimsListFault" use="literal"/>
+			</fault>
+		</operation>
+	
+		<operation name="declareEndpoint">
+			<soap:operation soapAction="urn:declareEndpoint" style="document" />
+			<input name="DeclareEndpointRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="DeclareEndpointResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="DeclareEndpointFault">
+				<soap:fault name="DeclareEndpointFault" use="literal"/>
+			</fault>
+		</operation>	
+		
+
+	</binding>
+	
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+	
+	
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy" 
+	  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	  xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+	  <wsp:ExactlyOne>
+		  <wsp:All>
+			<!-- Def HTTPS -->
+			<sp:TransportBinding>
+				<wsp:Policy>
+					<sp:TransportToken>
+						<wsp:Policy>
+							<sp:HttpsToken RequireClientCertificate="false"/>
+						</wsp:Policy>
+					</sp:TransportToken>
+				</wsp:Policy>
+			</sp:TransportBinding>
+			<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+			<sp:SupportingTokens>
+			  <wsp:Policy>
+				<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+				  <wsp:Policy>
+					<sp:HashPassword/>
+				  </wsp:Policy>
+				</sp:UsernameToken>
+			  </wsp:Policy>
+			</sp:SupportingTokens>
+
+		  </wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+  
+
+</definitions>

client-lib/src/main/resources/def/r1_1_1/omds3ServicesBroker.wsdl

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- version="1.1.1" -->
+
+<definitions 
+	name="omds3ServicesBroker-1-1-0" 
+	targetNamespace="urn:omds3ServicesBroker-1-1-0"
+	xmlns:os="urn:omds3ServicesBroker-1-1-0" 
+	xmlns:ost="urn:omds3ServiceTypes-1-1-0" 
+	xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" 
+	xmlns="http://schemas.xmlsoap.org/wsdl/"
+	xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" 
+	xmlns:ns="http://www.w3.org/2001/XMLSchema"
+	xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/" 
+	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+>
+	
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd" />
+		</schema>
+	</types>
+	
+	<!-- Schaden -->
+
+	
+	<message name="DeclareNewClaimStatusRequestMsg">
+		<part name="parameters" element="ost:DeclareNewClaimStatusRequest"/>
+	</message>
+	<message name="DeclareNewClaimStatusResponseMsg">
+		<part name="parameters" element="ost:DeclareNewClaimStatusResponse"/>
+	</message>
+
+	<message name="LossEventRegisteredRequestMsg">
+		<part name="parameters" element="ost:LossEventRegisteredRequest"/>
+	</message>
+	<message name="LossEventRegisteredResponseMsg">
+		<part name="parameters" element="ost:LossEventRegisteredResponse"/>
+	</message>
+	
+	<!-- Fehler Message -->	
+	<message name="BrokerServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+	
+	
+	<portType name="omdsBrokerServicePortType">
+	
+		<!-- Schaden -->
+		<operation name="declareNewClaimStatus">
+			<input name="DeclareNewClaimStatusRequestPort" message="os:DeclareNewClaimStatusRequestMsg" />
+			<output name="DeclareNewClaimStatusResponsePort" message="os:DeclareNewClaimStatusResponseMsg" />
+            <fault name="DeclareNewClaimStatusFault" message="os:BrokerServiceFaultMsg" />
+        </operation>
+
+		<operation name="lossEventRegistered">
+			<input name="LossEventRegisteredRequestPort" message="os:LossEventRegisteredRequestMsg" />
+			<output name="LossEventRegisteredResponsePort" message="os:LossEventRegisteredResponseMsg" />
+            <fault name="LossEventRegisteredFault" message="os:BrokerServiceFaultMsg" />
+        </operation>
+   	</portType>
+
+	<binding name="omdsBrokerServicePortBinding" type="os:omdsBrokerServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+
+		<!-- Schaden -->
+		<operation name="declareNewClaimStatus">
+			<soap:operation soapAction="urn:declareNewClaimStatus" style="document" />
+			<input name="DeclareNewClaimStatusRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="DeclareNewClaimStatusResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="DeclareNewClaimStatusFault">
+				<soap:fault name="DeclareNewClaimStatusFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="lossEventRegistered">
+			<soap:operation soapAction="urn:lossEventRegistered" style="document" />
+			<input name="LossEventRegisteredRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="LossEventRegisteredResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="LossEventRegisteredFault">
+				<soap:fault name="LossEventRegisteredFault" use="literal"/>
+			</fault>
+		</operation>
+	</binding>
+	
+	<service name="omdsBrokerService">
+		<port name="omdsBrokerServicePort" binding="os:omdsBrokerServicePortBinding">
+			<soap:address location="http://localhost:80/omdsBrokerServicePort" />
+		</port>
+	</service>
+		
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy" 
+	  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	  xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+	  <wsp:ExactlyOne>
+		  <wsp:All>
+			<!-- Def HTTPS -->
+			<sp:TransportBinding>
+				<wsp:Policy>
+					<sp:TransportToken>
+						<wsp:Policy>
+							<sp:HttpsToken RequireClientCertificate="false"/>
+						</wsp:Policy>
+					</sp:TransportToken>
+				</wsp:Policy>
+			</sp:TransportBinding>
+			<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+			<sp:SupportingTokens>
+			  <wsp:Policy>
+				<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+				  <wsp:Policy>
+					<sp:HashPassword/>
+				  </wsp:Policy>
+				</sp:UsernameToken>
+			  </wsp:Policy>
+			</sp:SupportingTokens>
+
+		  </wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+  
+</definitions>

client-lib/src/main/resources/def/r1_2_0/omds3CommonServiceTypes.xsd

@@ -0,0 +1,307 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3CommonServiceTypes-1-1-0" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" targetNamespace="urn:omds3CommonServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.1.1">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<!-- Elemente, die von allen Services gemeinsam verwendet werden -->
+	<xsd:element name="serviceFault" type="ServiceFault">
+		<xsd:annotation>
+			<xsd:documentation>Fault-Element, wie es von einer Soap-Operation im Falle eines Faults geworfen wird</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ServiceFault">
+		<xsd:annotation>
+			<xsd:documentation>Enthält eventuelle Fehlermeldungen + Fehlercode + Fehlertyp.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="errorType">
+				<xsd:annotation>
+					<xsd:documentation>Fehlertyp ( 1 = Fehler, 2 = Warnung, 3 = Hinweis)
+                    </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:integer">
+						<xsd:pattern value="1">
+							<xsd:annotation>
+								<xsd:documentation>Fehler</xsd:documentation>
+							</xsd:annotation>
+						</xsd:pattern>
+						<xsd:pattern value="2">
+							<xsd:annotation>
+								<xsd:documentation>Warnung</xsd:documentation>
+							</xsd:annotation>
+						</xsd:pattern>
+						<xsd:pattern value="3">
+							<xsd:annotation>
+								<xsd:documentation>Hinweis</xsd:documentation>
+							</xsd:annotation>
+						</xsd:pattern>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="errorCode" type="xsd:integer">
+				<xsd:annotation>
+					<xsd:documentation>Fehlercode entsprechend allgemeiner Fehlerliste
+                    </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="errorMsg" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Eine ausgeschriebene Fehlermeldung, für den User</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="GeschaeftsfallId_Type">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ einer GeschaeftsfallId</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string"/>
+	</xsd:simpleType>
+	<xsd:element name="GeschaeftsfallId" type="GeschaeftsfallId_Type">
+		<xsd:annotation>
+			<xsd:documentation>Eine GeschäftsfallId als String</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:simpleType name="OMDSVersion_Type">
+		<xsd:annotation>
+			<xsd:documentation>Die OMDS-Version als String</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:maxLength value="20"/>
+			<xsd:enumeration value="OMDS-Services 1.0.0"/>
+			<xsd:enumeration value="OMDS-Services 1.1.0"/>
+			<xsd:enumeration value="OMDS-Services 1.1.1"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="AuthorizationFilter" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen abstrakten Filter um bestimmte spezifische Elemente herauszufiltern</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="AgentFilter_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ein spezieller AuthorizationFilterType, der eine Anfrage dahingehend einschränkt, dass nur Ergebnisse für eine bestimmte MaklerID oder Vermnr (Vermittlernummer) zurück gegeben werden</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AuthorizationFilter">
+				<xsd:choice>
+					<xsd:element name="MaklerID" type="MaklerID_Type">
+						<xsd:annotation>
+							<xsd:documentation>Entspricht der MaklerID in der OMDS-Datensatzdefinition. Die MaklerID ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für das jeweilige VU, bei welchem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die MaklerID mit der Vermittlernummer (Vermnr) zusammenfällt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vermnr" type="omds:Vermnr" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Vermittlernummer vom Typ Vermnr aus der OMDS-Datensatz Definition. Die Vermittlernummer wird als Filterparameter verwendet, um eine Anfrage auf eine bestimmte Vermittlernummer zu beschränken, wenn der Benutzer auf mehrere Vermittlernummern berechtigt ist.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:choice>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="MaklerID_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine MaklerID als String mit mindestens einem und max. 26 Zeichen. Diese Typ-Definition entspricht der Definition des Attributs MaklerID im OMDS-Datensatz, in dem es aber keinen unabhaengigen, referenzierbaren Typ gibt.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="26"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ElementIdType">
+		<xsd:annotation>
+			<xsd:documentation>Ein Typ für eine Objekt-Id in Verbindung mit einem möglichen Ablaufzeitpunkt und dem Hinweis, ob die Id nur einmalig oder auch mehrmalig verwendet werden kann</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="id" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Elements als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="idValidUntil" type="xsd:dateTime">
+				<xsd:annotation>
+					<xsd:documentation>Die Gültigkeit der Id des Elements. Wenn die Gültigkeit "null", 
+					ist die Id unbegrenzt gueltig. Von der geplanten Gültigkeit unabhängig kann das 
+					Element dennoch aus anderen Gründen gelöscht werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="idIsSingleUse" type="xsd:boolean">
+				<xsd:annotation>
+					<xsd:documentation>wahr wenn die Id nur einmal verwendet werden kann, sonst falsch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="DocumentType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert die unterschiedlichen Dokumententypen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:int">
+			<xsd:minInclusive value="0"/>
+			<xsd:maxInclusive value="26"/>
+			<xsd:enumeration value="0">
+				<xsd:annotation>
+					<xsd:documentation>Sonstiges</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="1">
+				<xsd:annotation>
+					<xsd:documentation>Antrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="2">
+				<xsd:annotation>
+					<xsd:documentation>Deckungsbestätigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="3">
+				<xsd:annotation>
+					<xsd:documentation>Erstpolizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="4">
+				<xsd:annotation>
+					<xsd:documentation>Folgepolizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="5">
+				<xsd:annotation>
+					<xsd:documentation>Zusatzvereinbarungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="6">
+				<xsd:annotation>
+					<xsd:documentation>Vinkulierungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="7">
+				<xsd:annotation>
+					<xsd:documentation>Bewertungsgutachten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="8">
+				<xsd:annotation>
+					<xsd:documentation>Verständigung Gewinnbeteiligungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="9">
+				<xsd:annotation>
+					<xsd:documentation>Umsatz/Lohnsummenmeldung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="10">
+				<xsd:annotation>
+					<xsd:documentation>Umsatz/Lohnsummenabrechnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="11">
+				<xsd:annotation>
+					<xsd:documentation>BU-Summenmeldung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="12">
+				<xsd:annotation>
+					<xsd:documentation>BU-Summenabrechnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="13">
+				<xsd:annotation>
+					<xsd:documentation>Finanzamtsbestätigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="14">
+				<xsd:annotation>
+					<xsd:documentation>Kündigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="15">
+				<xsd:annotation>
+					<xsd:documentation>Stornopolizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="16">
+				<xsd:annotation>
+					<xsd:documentation>Schadenmeldung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="17">
+				<xsd:annotation>
+					<xsd:documentation>Schadennachtrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="18">
+				<xsd:annotation>
+					<xsd:documentation>Gutachten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="19">
+				<xsd:annotation>
+					<xsd:documentation>Behördliche Anzeigebestätigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="20">
+				<xsd:annotation>
+					<xsd:documentation>Kostenvoranschlag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="21">
+				<xsd:annotation>
+					<xsd:documentation>Rechnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="22">
+				<xsd:annotation>
+					<xsd:documentation>Schadenablehnung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="23">
+				<xsd:annotation>
+					<xsd:documentation>Schadenfoto</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="24">
+				<xsd:annotation>
+					<xsd:documentation>Abfindungserklärung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="25">
+				<xsd:annotation>
+					<xsd:documentation>Restwertangebot</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="26">
+				<xsd:annotation>
+					<xsd:documentation>Schreiben Rechtsanwalt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<!-- Dokumententypen Schaden -->
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="PartnerRoleType">
+		<xsd:annotation>
+			<xsd:documentation>Definition der Partnerrollen über jeweils 2 Buchstaben. Typ wurde angelehnt an VtgRolleCd_Type, allerdings wurde neuer Typ benötigt, da Versicherte Person als Partnerrolle relevant ist.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:length value="2"/>
+			<xsd:enumeration value="VN">
+				<xsd:annotation>
+					<xsd:documentation>Versicherungsnehmer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VP">
+				<xsd:annotation>
+					<xsd:documentation>Versicherte Person</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:element name="OrdnungsbegriffZuordFremd">
+		<xsd:annotation>
+			<xsd:documentation>Ein Ordnungsbegriff aus einem Fremdsystem, welcher dabei hilft die Kommunikation zwischen zwei Systemen zu vereinfachen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:simpleType>
+			<xsd:restriction base="xsd:string">
+				<xsd:maxLength value="255"/>
+			</xsd:restriction>
+		</xsd:simpleType>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_2_0/omds3ExampleVuServiceTypes.xsd

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:omds="urn:omds20" xmlns:ost="urn:omds3ServiceTypes-1-1-0" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="urn:exampleVuServiceTypes" targetNamespace="urn:exampleVuServiceTypes" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.1.1">
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<!-- Beispiel fuer die Erweiterung eines Typs fuer die speziellen Belange einer VU  -->
+	<xsd:complexType name="UserDataResponseExampleVU">
+		<xsd:complexContent>
+			<xsd:extension base="ost:UserDataResponse">
+				<xsd:sequence>
+					<xsd:element name="role" type="xsd:string"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_2_0/omds3Services.wsdl

@@ -0,0 +1,629 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- version="1.1.1" -->
+<definitions 
+	name="omds3Services-1-1-0" 
+	xmlns:os="urn:omds3Services-1-1-0"
+	targetNamespace="urn:omds3Services-1-1-0"
+	xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" 
+	xmlns:ost="urn:omds3ServiceTypes-1-1-0" 
+	xmlns="http://schemas.xmlsoap.org/wsdl/"
+	xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" 
+	xmlns:ns="http://www.w3.org/2001/XMLSchema"
+	xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/" 
+	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+>
+	
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd" />
+		</schema>
+	</types>
+
+	<message name="loginRequest">
+		<part name="parameters" element="ost:loginRequest"/>
+	</message>
+	<message name="loginResponse">
+		<part name="parameters" element="ost:loginResponse"/>
+	</message>
+
+
+	<message name="getUserDataRequest">
+		<part name="parameters" element="ost:getUserDataRequest"/>
+	</message>
+	<message name="getUserDataResponse">
+		<part name="parameters" element="ost:getUserDataResponse"/>
+	</message>
+
+	
+	<message name="getOMDSPackageListRequest">
+		<part name="parameters" element="ost:getOMDSPackageListRequest"/>
+	</message>
+	<message name="getOMDSPackageListResponse">
+		<part name="parameters" element="ost:getOMDSPackageListResponse" />
+	</message>
+
+
+	<message name="getOMDSPackageRequest">
+		<part name="parameters" element="ost:getOMDSPackageRequest"/>
+	</message>
+	<message name="getOMDSPackageResponse">
+		<part name="parameters" element="ost:getOMDSPackageResponse" />
+	</message>
+	
+	<!-- Vertragsbezogene Dokumente -->
+	
+	<message name="getArcImageInfosRequest">
+		<part name="parameters" element="ost:getArcImageInfosRequest"/>
+	</message>
+	<message name="getArcImageInfosResponse">
+		<part name="parameters" element="ost:getArcImageInfosResponse" />
+	</message>
+	<message name="getArcImageRequest">
+		<part name="parameters" element="ost:getArcImageRequest"/>
+	</message>
+	<message name="getArcImageResponse">
+		<part name="parameters" element="ost:getArcImageResponse" />
+	</message>
+	
+	<!-- Deep Links -->
+	
+	<message name="deepLinkClaimRequest">
+		<part name="parameters" element="ost:getDeepLinkClaimRequest"/>
+	</message>
+	<message name="deepLinkClaimResponse">
+		<part name="parameters" element="ost:getDeepLinkClaimResponse" />
+	</message>
+	
+	<message name="deepLinkPartnerRequest">
+		<part name="parameters" element="ost:getDeepLinkPartnerRequest"/>
+	</message>
+	<message name="deepLinkPartnerResponse">
+		<part name="parameters" element="ost:getDeepLinkPartnerResponse" />
+	</message>
+	<message name="deepLinkOfferRequest">
+		<part name="parameters" element="ost:getDeepLinkOfferRequest"/>
+	</message>
+	<message name="deepLinkOfferResponse">
+		<part name="parameters" element="ost:getDeepLinkOfferResponse" />
+	</message>
+	<message name="deepLinkPolicyRequest">
+		<part name="parameters" element="ost:getDeepLinkPolicyRequest"/>
+	</message>
+	<message name="deepLinkPolicyResponse">
+		<part name="parameters" element="ost:getDeepLinkPolicyResponse" />
+	</message>
+	<!-- Schaden -->
+	<message name="CreateClaimRequestMsg">
+		<part name="parameters" element="ost:CreateClaimRequest"/>
+	</message>
+	<message name="CreateClaimResponseMsg">
+		<part name="parameters" element="ost:CreateClaimResponse" />
+	</message>
+	
+	<message name="InitiateClaimRequestMsg">
+		<part name="parameters" element="ost:InitiateClaimRequest"/>
+	</message>
+	<message name="InitiateClaimResponseMsg">
+		<part name="parameters" element="ost:InitiateClaimResponse" />
+	</message>
+	
+	
+	<message name="AddDocToClaimRequestMsg">
+		<part name="parameters" element="ost:AddDocToClaimRequest"/>
+	</message>
+	<message name="AddDocToClaimResponseMsg">
+		<part name="parameters" element="ost:AddDocToClaimResponse" />
+	</message>
+		
+	<message name="GetClaimRequestMsg">
+		<part name="parameters" element="ost:GetClaimRequest"/>
+	</message>
+	<message name="GetClaimResponseMsg">
+		<part name="parameters" element="ost:GetClaimResponse" />
+	</message>	
+	<message name="GetClaimLightRequestMsg">
+		<part name="parameters" element="ost:GetClaimLightRequest"/>
+	</message>
+	<message name="GetClaimLightResponseMsg">
+		<part name="parameters" element="ost:GetClaimLightResponse" />
+	</message>	
+	<message name="GetNumberOfDocumentsRequestMsg">
+		<part name="parameters" element="ost:GetNumberOfDocumentsRequest"/>
+	</message>
+	<message name="GetNumberOfDocumentsResponseMsg">
+		<part name="parameters" element="ost:GetNumberOfDocumentsResponse" />
+	</message>	
+	<message name="GetDocumentInfosRequestMsg">
+		<part name="parameters" element="ost:GetDocumentInfosRequest"/>
+	</message>
+	<message name="GetDocumentInfosResponseMsg">
+		<part name="parameters" element="ost:GetDocumentInfosResponse" />
+	</message>	
+	<message name="SearchClaimRequestMsg">
+		<part name="parameters" element="ost:SearchClaimRequest"/>
+	</message>
+	<message name="SearchClaimResponseMsg">
+		<part name="parameters" element="ost:SearchClaimResponse" />
+	</message>		
+	
+	<message name="GetLossEventListRequestMsg">
+		<part name="parameters" element="ost:LossEventListRequest"/>
+	</message>
+	<message name="GetLossEventListResponseMsg">
+		<part name="parameters" element="ost:LossEventListResponse" />
+	</message>		
+	<message name="GetChangedClaimsListRequestMsg">
+		<part name="parameters" element="ost:ChangedClaimsListRequest"/>
+	</message>
+	<message name="GetChangedClaimsListResponseMsg">
+		<part name="parameters" element="ost:ChangedClaimsListResponse" />
+	</message>		
+	
+	
+	<message name="DeclareEndpointRequestMsg">
+		<part name="parameters" element="ost:DeclareEndpointRequest"/>
+	</message>
+	<message name="DeclareEndpointResponseMsg">
+		<part name="parameters" element="ost:DeclareEndpointResponse" />
+	</message>	
+	
+	
+	<!-- Fehler -->	
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+	
+	
+	<portType name="omdsServicePortType">
+
+		<operation name="login">
+			<input name="loginRequest" message="os:loginRequest" />
+			<output name="loginResponse" message="os:loginResponse" />
+            <fault name="loginFault" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="getUserData">
+			<input name="getUserDataRequest" message="os:getUserDataRequest" />
+			<output name="getUserDataResponse" message="os:getUserDataResponse" />
+			<fault name="getUserDataFault" message="os:ServiceFaultMsg" />
+		</operation>
+	
+		<operation name="getOMDSPackageList">
+			<input name="getOMDSPackageListRequest" message="os:getOMDSPackageListRequest" />
+			<output name="getOMDSPackageListResponse" message="os:getOMDSPackageListResponse" />
+			<fault name="getOMDSPackageListFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<input name="getOMDSPackageRequest" message="os:getOMDSPackageRequest" />
+			<output name="getOMDSPackageResponse" message="os:getOMDSPackageResponse" />
+			<fault name="getOMDSPackageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImageInfos">
+			<input name="getArcImageInfosRequest" message="os:getArcImageInfosRequest" />
+			<output name="getArcImageInfosResponse" message="os:getArcImageInfosResponse" />
+			<fault name="getArcImageInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImage">
+			<input name="getArcImageRequest" message="os:getArcImageRequest" />
+			<output name="getArcImageResponse" message="os:getArcImageResponse" />
+			<fault name="getArcImageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkClaim">
+			<input name="deepLinkClaimRequest" message="os:deepLinkClaimRequest" />
+			<output name="deepLinkClaimResponse" message="os:deepLinkClaimResponse" />
+			<fault name="deepLinkClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<input name="deepLinkPartnerRequest" message="os:deepLinkPartnerRequest" />
+			<output name="deepLinkPartnerResponse" message="os:deepLinkPartnerResponse" />
+			<fault name="deepLinkPartnerFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<input name="deepLinkOfferRequest" message="os:deepLinkOfferRequest" />
+			<output name="deepLinkOfferResponse" message="os:deepLinkOfferResponse" />
+			<fault name="deepLinkOfferFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<input name="deepLinkPolicyRequest" message="os:deepLinkPolicyRequest" />
+			<output name="deepLinkPolicyResponse" message="os:deepLinkPolicyResponse" />
+			<fault name="deepLinkPolicyFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="createClaim">
+			<input name="CreateClaimRequestPort" message="os:CreateClaimRequestMsg" />
+			<output name="CreateClaimResponsePort" message="os:CreateClaimResponseMsg" />
+			<fault name="CreateClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		
+		<operation name="initiateClaim">
+			<input name="InitiateClaimRequestPort" message="os:InitiateClaimRequestMsg" />
+			<output name="InitiateClaimResponsePort" message="os:InitiateClaimResponseMsg" />
+			<fault name="InitiateClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+	
+		<operation name="addDocToClaim">
+			<input name="AddDocToClaimRequestPort" message="os:AddDocToClaimRequestMsg" />
+			<output name="AddDocToClaimResponsePort" message="os:AddDocToClaimResponseMsg" />
+			<fault name="AddDocToClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaim">
+			<input name="GetClaimRequestPort" message="os:GetClaimRequestMsg" />
+			<output name="GetClaimResponsePort" message="os:GetClaimResponseMsg" />
+			<fault name="GetClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaimLight">
+			<input name="GetClaimLightRequestPort" message="os:GetClaimLightRequestMsg" />
+			<output name="GetClaimLightResponsePort" message="os:GetClaimLightResponseMsg" />
+			<fault name="GetClaimLightFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getNumberOfDocuments">
+			<input name="GetNumberOfDocumentsRequestPort" message="os:GetNumberOfDocumentsRequestMsg" />
+			<output name="GetNumberOfDocumentsResponsePort" message="os:GetNumberOfDocumentsResponseMsg" />
+			<fault name="GetNumberOfDocumentsFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentInfos">
+			<input name="GetDocumentInfosRequestPort" message="os:GetDocumentInfosRequestMsg" />
+			<output name="GetDocumentInfosResponsePort" message="os:GetDocumentInfosResponseMsg" />
+			<fault name="GetDocumentInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="searchClaim">
+			<input name="SearchClaimRequestPort" message="os:SearchClaimRequestMsg" />
+			<output name="SearchClaimResponsePort" message="os:SearchClaimResponseMsg" />
+			<fault name="SearchClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getLossEventList">
+			<input name="LossEventListRequestPort" message="os:GetLossEventListRequestMsg" />
+			<output name="LossEventListResponsePort" message="os:GetLossEventListResponseMsg" />
+			<fault name="LossEventListFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getChangedClaimsList">
+			<input name="ChangedClaimsListPort" message="os:GetChangedClaimsListRequestMsg" />
+			<output name="ChangedClaimsListResponsePort" message="os:GetChangedClaimsListResponseMsg" />
+			<fault name="ChangedClaimsListFault" message="os:ServiceFaultMsg" />
+		</operation>		
+		<operation name="declareEndpoint">
+			<input name="DeclareEndpointRequestPort" message="os:DeclareEndpointRequestMsg" />
+			<output name="DeclareEndpointResponsePort" message="os:DeclareEndpointResponseMsg" />
+			<fault name="DeclareEndpointFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+		
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+		
+		
+		<operation name="login">
+			<soap:operation soapAction="urn:login" style="document" />
+			<input name="loginRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="loginResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="loginFault">
+				<soap:fault name="loginFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getUserData">
+			<soap:operation soapAction="urn:getUserData" style="document" />
+			<input name="getUserDataRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getUserDataResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getUserDataFault">
+				<soap:fault name="getUserDataFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<soap:operation soapAction="urn:getOMDSPackageList" style="document" />
+			<input name="getOMDSPackageListRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageListResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageListFault">
+				<soap:fault name="getOMDSPackageListFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getOMDSPackage">
+			<soap:operation soapAction="urn:getOMDSPackage" style="document" />
+			<input name="getOMDSPackageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageFault">
+				<soap:fault name="getOMDSPackageFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<!-- Vertragsbezogene Dokumente ArcImage -->
+		
+		<operation name="getArcImageInfos">
+			<soap:operation soapAction="urn:getArcImageInfos" style="document" />
+			<input name="getArcImageInfosRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageInfosResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageInfosFault">
+				<soap:fault name="getArcImageInfosFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getArcImage">
+			<soap:operation soapAction="urn:getArcImage" style="document" />
+			<input name="getArcImageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageFault">
+				<soap:fault name="getArcImageFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<!-- Deep-Links -->
+		
+		<operation name="deepLinkClaim">
+			<soap:operation soapAction="urn:deepLinkClaim" style="document" />
+			<input name="deepLinkClaimRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkClaimResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkClaimFault">
+				<soap:fault name="deepLinkClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkPartner">
+			<soap:operation soapAction="urn:deepLinkPartner" style="document" />
+			<input name="deepLinkPartnerRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPartnerResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPartnerFault">
+				<soap:fault name="deepLinkPartnerFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkOffer">
+			<soap:operation soapAction="urn:deepLinkOffer" style="document" />
+			<input name="deepLinkOfferRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkOfferResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkOfferFault">
+				<soap:fault name="deepLinkOfferFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkPolicy">
+			<soap:operation soapAction="urn:deepLinkPolicy" style="document" />
+			<input name="deepLinkPolicyRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPolicyResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPolicyFault">
+				<soap:fault name="deepLinkPolicyFault" use="literal"/>
+			</fault>
+		</operation>
+	
+		<!-- Schaden -->
+		<operation name="createClaim">
+			<soap:operation soapAction="urn:createClaim" style="document" />
+			<input name="CreateClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="CreateClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="CreateClaimFault">
+				<soap:fault name="CreateClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="initiateClaim">
+			<soap:operation soapAction="urn:initiateClaim" style="document" />
+			<input name="InitiateClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="InitiateClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="InitiateClaimFault">
+				<soap:fault name="InitiateClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+
+		<operation name="addDocToClaim">
+			<soap:operation soapAction="urn:addDocToClaim" style="document" />
+			<input name="AddDocToClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="AddDocToClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="AddDocToClaimFault">
+				<soap:fault name="AddDocToClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getClaim">
+			<soap:operation soapAction="urn:getClaim" style="document" />
+			<input name="GetClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimFault">
+				<soap:fault name="GetClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getClaimLight">
+			<soap:operation soapAction="urn:getClaimLight" style="document" />
+			<input name="GetClaimLightRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimLightResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimLightFault">
+				<soap:fault name="GetClaimLightFault" use="literal"/>
+			</fault>
+		</operation>
+				
+		<operation name="getNumberOfDocuments">
+			<soap:operation soapAction="urn:getNumberOfDocuments" style="document" />
+			<input name="GetNumberOfDocumentsRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetNumberOfDocumentsResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetNumberOfDocumentsFault">
+				<soap:fault name="GetNumberOfDocumentsFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getDocumentInfos">
+			<soap:operation soapAction="urn:getDocumentInfos" style="document" />
+			<input name="GetDocumentInfosRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentInfosResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentInfosFault">
+				<soap:fault name="GetDocumentInfosFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="searchClaim">
+			<soap:operation soapAction="urn:searchClaim" style="document" />
+			<input name="SearchClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SearchClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SearchClaimFault">
+				<soap:fault name="SearchClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getLossEventList">
+			<soap:operation soapAction="urn:getLossEventList" style="document" />
+			<input name="LossEventListRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="LossEventListResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="LossEventListFault">
+				<soap:fault name="LossEventListFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getChangedClaimsList">
+			<soap:operation soapAction="urn:getChangedClaimsList" style="document" />
+			<input name="ChangedClaimsListPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="ChangedClaimsListResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="ChangedClaimsListFault">
+				<soap:fault name="ChangedClaimsListFault" use="literal"/>
+			</fault>
+		</operation>
+	
+		<operation name="declareEndpoint">
+			<soap:operation soapAction="urn:declareEndpoint" style="document" />
+			<input name="DeclareEndpointRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="DeclareEndpointResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="DeclareEndpointFault">
+				<soap:fault name="DeclareEndpointFault" use="literal"/>
+			</fault>
+		</operation>	
+		
+
+	</binding>
+	
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+	
+	
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy" 
+	  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	  xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+	  <wsp:ExactlyOne>
+		  <wsp:All>
+			<!-- Def HTTPS -->
+			<sp:TransportBinding>
+				<wsp:Policy>
+					<sp:TransportToken>
+						<wsp:Policy>
+							<sp:HttpsToken RequireClientCertificate="false"/>
+						</wsp:Policy>
+					</sp:TransportToken>
+				</wsp:Policy>
+			</sp:TransportBinding>
+			<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+			<sp:SupportingTokens>
+			  <wsp:Policy>
+				<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+				  <wsp:Policy>
+					<sp:HashPassword/>
+				  </wsp:Policy>
+				</sp:UsernameToken>
+			  </wsp:Policy>
+			</sp:SupportingTokens>
+
+		  </wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+  
+
+</definitions>

client-lib/src/main/resources/def/r1_2_0/omds3ServicesBroker.wsdl

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- version="1.1.1" -->
+
+<definitions 
+	name="omds3ServicesBroker-1-1-0" 
+	targetNamespace="urn:omds3ServicesBroker-1-1-0"
+	xmlns:os="urn:omds3ServicesBroker-1-1-0" 
+	xmlns:ost="urn:omds3ServiceTypes-1-1-0" 
+	xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" 
+	xmlns="http://schemas.xmlsoap.org/wsdl/"
+	xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" 
+	xmlns:ns="http://www.w3.org/2001/XMLSchema"
+	xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/" 
+	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+>
+	
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd" />
+		</schema>
+	</types>
+	
+	<!-- Schaden -->
+
+	
+	<message name="DeclareNewClaimStatusRequestMsg">
+		<part name="parameters" element="ost:DeclareNewClaimStatusRequest"/>
+	</message>
+	<message name="DeclareNewClaimStatusResponseMsg">
+		<part name="parameters" element="ost:DeclareNewClaimStatusResponse"/>
+	</message>
+
+	<message name="LossEventRegisteredRequestMsg">
+		<part name="parameters" element="ost:LossEventRegisteredRequest"/>
+	</message>
+	<message name="LossEventRegisteredResponseMsg">
+		<part name="parameters" element="ost:LossEventRegisteredResponse"/>
+	</message>
+	
+	<!-- Fehler Message -->	
+	<message name="BrokerServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+	
+	
+	<portType name="omdsBrokerServicePortType">
+	
+		<!-- Schaden -->
+		<operation name="declareNewClaimStatus">
+			<input name="DeclareNewClaimStatusRequestPort" message="os:DeclareNewClaimStatusRequestMsg" />
+			<output name="DeclareNewClaimStatusResponsePort" message="os:DeclareNewClaimStatusResponseMsg" />
+            <fault name="DeclareNewClaimStatusFault" message="os:BrokerServiceFaultMsg" />
+        </operation>
+
+		<operation name="lossEventRegistered">
+			<input name="LossEventRegisteredRequestPort" message="os:LossEventRegisteredRequestMsg" />
+			<output name="LossEventRegisteredResponsePort" message="os:LossEventRegisteredResponseMsg" />
+            <fault name="LossEventRegisteredFault" message="os:BrokerServiceFaultMsg" />
+        </operation>
+   	</portType>
+
+	<binding name="omdsBrokerServicePortBinding" type="os:omdsBrokerServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+
+		<!-- Schaden -->
+		<operation name="declareNewClaimStatus">
+			<soap:operation soapAction="urn:declareNewClaimStatus" style="document" />
+			<input name="DeclareNewClaimStatusRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="DeclareNewClaimStatusResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="DeclareNewClaimStatusFault">
+				<soap:fault name="DeclareNewClaimStatusFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="lossEventRegistered">
+			<soap:operation soapAction="urn:lossEventRegistered" style="document" />
+			<input name="LossEventRegisteredRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="LossEventRegisteredResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="LossEventRegisteredFault">
+				<soap:fault name="LossEventRegisteredFault" use="literal"/>
+			</fault>
+		</operation>
+	</binding>
+	
+	<service name="omdsBrokerService">
+		<port name="omdsBrokerServicePort" binding="os:omdsBrokerServicePortBinding">
+			<soap:address location="http://localhost:80/omdsBrokerServicePort" />
+		</port>
+	</service>
+		
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy" 
+	  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	  xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+	  <wsp:ExactlyOne>
+		  <wsp:All>
+			<!-- Def HTTPS -->
+			<sp:TransportBinding>
+				<wsp:Policy>
+					<sp:TransportToken>
+						<wsp:Policy>
+							<sp:HttpsToken RequireClientCertificate="false"/>
+						</wsp:Policy>
+					</sp:TransportToken>
+				</wsp:Policy>
+			</sp:TransportBinding>
+			<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+			<sp:SupportingTokens>
+			  <wsp:Policy>
+				<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+				  <wsp:Policy>
+					<sp:HashPassword/>
+				  </wsp:Policy>
+				</sp:UsernameToken>
+			  </wsp:Policy>
+			</sp:SupportingTokens>
+
+		  </wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+  
+</definitions>

client-lib/src/main/resources/def/r1_3_0/omds3Services.wsdl

@@ -0,0 +1,748 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<definitions name="omds3Services-1-1-0" targetNamespace="urn:omds3Services-1-1-0" 
+xmlns:os="urn:omds3Services-1-1-0" 
+xmlns:ost="urn:omds3ServiceTypes-1-1-0" 
+xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" 
+xmlns:b="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen"
+xmlns:boak="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz"
+xmlns="http://schemas.xmlsoap.org/wsdl/" 
+xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" 
+xmlns:ns="http://www.w3.org/2001/XMLSchema" 
+xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/" 
+xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/" 
+xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
+xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+	<!-- 
+	hier wird exampleVuServiceTypes.xsd referenziert, welches stellvertretend fuer eine individuelle
+	Erweiterung der omdsServiceTypes.xsd einer VU steht. So besteht die Möglichkeit die Requests und 
+	Responses um weitere Attribute zu erweitern 
+	-->
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" schemaLocation="omds3_ON1_Basisfunktionen.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" schemaLocation="omds3_ON2_Antrag_Kfz.xsd"/>
+		</schema>
+	</types>
+
+	<message name="loginRequest">
+		<part name="parameters" element="ost:loginRequest"/>
+	</message>
+	<message name="loginResponse">
+		<part name="parameters" element="ost:loginResponse"/>
+	</message>
+
+
+	<message name="getUserDataRequest">
+		<part name="parameters" element="ost:getUserDataRequest"/>
+	</message>
+	<message name="getUserDataResponse">
+		<part name="parameters" element="ost:getUserDataResponse"/>
+	</message>
+
+	
+	<message name="getOMDSPackageListRequest">
+		<part name="parameters" element="ost:getOMDSPackageListRequest"/>
+	</message>
+	<message name="getOMDSPackageListResponse">
+		<part name="parameters" element="ost:getOMDSPackageListResponse" />
+	</message>
+
+
+	<message name="getOMDSPackageRequest">
+		<part name="parameters" element="ost:getOMDSPackageRequest"/>
+	</message>
+	<message name="getOMDSPackageResponse">
+		<part name="parameters" element="ost:getOMDSPackageResponse" />
+	</message>
+	
+	<!-- Vertragsbezogene Dokumente -->
+	
+	<message name="getArcImageInfosRequest">
+		<part name="parameters" element="ost:getArcImageInfosRequest"/>
+	</message>
+	<message name="getArcImageInfosResponse">
+		<part name="parameters" element="ost:getArcImageInfosResponse" />
+	</message>
+	<message name="getArcImageRequest">
+		<part name="parameters" element="ost:getArcImageRequest"/>
+	</message>
+	<message name="getArcImageResponse">
+		<part name="parameters" element="ost:getArcImageResponse" />
+	</message>
+	
+	<!-- Deep Links -->
+	
+	<message name="deepLinkClaimRequest">
+		<part name="parameters" element="ost:getDeepLinkClaimRequest"/>
+	</message>
+	<message name="deepLinkClaimResponse">
+		<part name="parameters" element="ost:getDeepLinkClaimResponse" />
+	</message>
+	
+	<message name="deepLinkPartnerRequest">
+		<part name="parameters" element="ost:getDeepLinkPartnerRequest"/>
+	</message>
+	<message name="deepLinkPartnerResponse">
+		<part name="parameters" element="ost:getDeepLinkPartnerResponse" />
+	</message>
+	<message name="deepLinkOfferRequest">
+		<part name="parameters" element="ost:getDeepLinkOfferRequest"/>
+	</message>
+	<message name="deepLinkOfferResponse">
+		<part name="parameters" element="ost:getDeepLinkOfferResponse" />
+	</message>
+	<message name="deepLinkPolicyRequest">
+		<part name="parameters" element="ost:getDeepLinkPolicyRequest"/>
+	</message>
+	<message name="deepLinkPolicyResponse">
+		<part name="parameters" element="ost:getDeepLinkPolicyResponse" />
+	</message>
+	<!-- Schaden -->
+	<message name="CreateClaimRequestMsg">
+		<part name="parameters" element="ost:CreateClaimRequest"/>
+	</message>
+	<message name="CreateClaimResponseMsg">
+		<part name="parameters" element="ost:CreateClaimResponse" />
+	</message>
+	
+	<message name="InitiateClaimRequestMsg">
+		<part name="parameters" element="ost:InitiateClaimRequest"/>
+	</message>
+	<message name="InitiateClaimResponseMsg">
+		<part name="parameters" element="ost:InitiateClaimResponse" />
+	</message>
+	
+	
+	<message name="AddDocToClaimRequestMsg">
+		<part name="parameters" element="ost:AddDocToClaimRequest"/>
+	</message>
+	<message name="AddDocToClaimResponseMsg">
+		<part name="parameters" element="ost:AddDocToClaimResponse" />
+	</message>
+		
+	<message name="GetClaimRequestMsg">
+		<part name="parameters" element="ost:GetClaimRequest"/>
+	</message>
+	<message name="GetClaimResponseMsg">
+		<part name="parameters" element="ost:GetClaimResponse" />
+	</message>	
+	<message name="GetClaimLightRequestMsg">
+		<part name="parameters" element="ost:GetClaimLightRequest"/>
+	</message>
+	<message name="GetClaimLightResponseMsg">
+		<part name="parameters" element="ost:GetClaimLightResponse" />
+	</message>	
+	<message name="GetNumberOfDocumentsRequestMsg">
+		<part name="parameters" element="ost:GetNumberOfDocumentsRequest"/>
+	</message>
+	<message name="GetNumberOfDocumentsResponseMsg">
+		<part name="parameters" element="ost:GetNumberOfDocumentsResponse" />
+	</message>	
+	<message name="GetDocumentInfosRequestMsg">
+		<part name="parameters" element="ost:GetDocumentInfosRequest"/>
+	</message>
+	<message name="GetDocumentInfosResponseMsg">
+		<part name="parameters" element="ost:GetDocumentInfosResponse" />
+	</message>	
+	<message name="SearchClaimRequestMsg">
+		<part name="parameters" element="ost:SearchClaimRequest"/>
+	</message>
+	<message name="SearchClaimResponseMsg">
+		<part name="parameters" element="ost:SearchClaimResponse" />
+	</message>		
+	
+	<message name="GetLossEventListRequestMsg">
+		<part name="parameters" element="ost:LossEventListRequest"/>
+	</message>
+	<message name="GetLossEventListResponseMsg">
+		<part name="parameters" element="ost:LossEventListResponse" />
+	</message>		
+	<message name="GetChangedClaimsListRequestMsg">
+		<part name="parameters" element="ost:ChangedClaimsListRequest"/>
+	</message>
+	<message name="GetChangedClaimsListResponseMsg">
+		<part name="parameters" element="ost:ChangedClaimsListResponse" />
+	</message>		
+	
+	
+	<message name="DeclareEndpointRequestMsg">
+		<part name="parameters" element="ost:DeclareEndpointRequest"/>
+	</message>
+	<message name="DeclareEndpointResponseMsg">
+		<part name="parameters" element="ost:DeclareEndpointResponse"/>
+	</message>
+	<message name="CalculateKfzRequestMsg">
+		<part name="parameters" element="boak:CalculateKfzRequest"/>
+	</message>
+	<message name="CalculateKfzResponseMsg">
+		<part name="parameters" element="boak:CalculateKfzResponse"/>
+	</message>
+	<message name="CreateOfferKfzRequestMsg">
+		<part name="parameters" element="boak:CreateOfferKfzRequest"/>
+	</message>
+	<message name="CreateOfferKfzResponseMsg">
+		<part name="parameters" element="boak:CreateOfferKfzResponse"/>
+	</message>
+	<message name="CreateApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzRequest"/>
+	</message>
+	<message name="CreateApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzResponse"/>
+	</message>
+	<message name="SubmitApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzRequest"/>
+	</message>
+	<message name="SubmitApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzResponse"/>
+	</message>	
+	<message name="GetStateChangesRequestMsg">
+		<part name="parameters" element="b:GetStateChangesRequest"/>
+	</message>
+	<message name="GetStateChangesResponseMsg">
+		<part name="parameters" element="b:GetStateChangesResponse"/>
+	</message>
+
+	<!-- Fehler -->
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+	
+	
+	<portType name="omdsServicePortType">
+
+		<operation name="login">
+			<input name="loginRequest" message="os:loginRequest" />
+			<output name="loginResponse" message="os:loginResponse" />
+            <fault name="loginFault" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="getUserData">
+			<input name="getUserDataRequest" message="os:getUserDataRequest" />
+			<output name="getUserDataResponse" message="os:getUserDataResponse" />
+			<fault name="getUserDataFault" message="os:ServiceFaultMsg" />
+		</operation>
+	
+		<operation name="getOMDSPackageList">
+			<input name="getOMDSPackageListRequest" message="os:getOMDSPackageListRequest" />
+			<output name="getOMDSPackageListResponse" message="os:getOMDSPackageListResponse" />
+			<fault name="getOMDSPackageListFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<input name="getOMDSPackageRequest" message="os:getOMDSPackageRequest" />
+			<output name="getOMDSPackageResponse" message="os:getOMDSPackageResponse" />
+			<fault name="getOMDSPackageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImageInfos">
+			<input name="getArcImageInfosRequest" message="os:getArcImageInfosRequest" />
+			<output name="getArcImageInfosResponse" message="os:getArcImageInfosResponse" />
+			<fault name="getArcImageInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImage">
+			<input name="getArcImageRequest" message="os:getArcImageRequest" />
+			<output name="getArcImageResponse" message="os:getArcImageResponse" />
+			<fault name="getArcImageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkClaim">
+			<input name="deepLinkClaimRequest" message="os:deepLinkClaimRequest" />
+			<output name="deepLinkClaimResponse" message="os:deepLinkClaimResponse" />
+			<fault name="deepLinkClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<input name="deepLinkPartnerRequest" message="os:deepLinkPartnerRequest" />
+			<output name="deepLinkPartnerResponse" message="os:deepLinkPartnerResponse" />
+			<fault name="deepLinkPartnerFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<input name="deepLinkOfferRequest" message="os:deepLinkOfferRequest" />
+			<output name="deepLinkOfferResponse" message="os:deepLinkOfferResponse" />
+			<fault name="deepLinkOfferFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<input name="deepLinkPolicyRequest" message="os:deepLinkPolicyRequest" />
+			<output name="deepLinkPolicyResponse" message="os:deepLinkPolicyResponse" />
+			<fault name="deepLinkPolicyFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="createClaim">
+			<input name="CreateClaimRequestPort" message="os:CreateClaimRequestMsg" />
+			<output name="CreateClaimResponsePort" message="os:CreateClaimResponseMsg" />
+			<fault name="CreateClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		
+		<operation name="initiateClaim">
+			<input name="InitiateClaimRequestPort" message="os:InitiateClaimRequestMsg" />
+			<output name="InitiateClaimResponsePort" message="os:InitiateClaimResponseMsg" />
+			<fault name="InitiateClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+	
+		<operation name="addDocToClaim">
+			<input name="AddDocToClaimRequestPort" message="os:AddDocToClaimRequestMsg" />
+			<output name="AddDocToClaimResponsePort" message="os:AddDocToClaimResponseMsg" />
+			<fault name="AddDocToClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaim">
+			<input name="GetClaimRequestPort" message="os:GetClaimRequestMsg" />
+			<output name="GetClaimResponsePort" message="os:GetClaimResponseMsg" />
+			<fault name="GetClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaimLight">
+			<input name="GetClaimLightRequestPort" message="os:GetClaimLightRequestMsg" />
+			<output name="GetClaimLightResponsePort" message="os:GetClaimLightResponseMsg" />
+			<fault name="GetClaimLightFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getNumberOfDocuments">
+			<input name="GetNumberOfDocumentsRequestPort" message="os:GetNumberOfDocumentsRequestMsg" />
+			<output name="GetNumberOfDocumentsResponsePort" message="os:GetNumberOfDocumentsResponseMsg" />
+			<fault name="GetNumberOfDocumentsFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentInfos">
+			<input name="GetDocumentInfosRequestPort" message="os:GetDocumentInfosRequestMsg" />
+			<output name="GetDocumentInfosResponsePort" message="os:GetDocumentInfosResponseMsg" />
+			<fault name="GetDocumentInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="searchClaim">
+			<input name="SearchClaimRequestPort" message="os:SearchClaimRequestMsg" />
+			<output name="SearchClaimResponsePort" message="os:SearchClaimResponseMsg" />
+			<fault name="SearchClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getLossEventList">
+			<input name="LossEventListRequestPort" message="os:GetLossEventListRequestMsg" />
+			<output name="LossEventListResponsePort" message="os:GetLossEventListResponseMsg" />
+			<fault name="LossEventListFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getChangedClaimsList">
+			<input name="ChangedClaimsListPort" message="os:GetChangedClaimsListRequestMsg" />
+			<output name="ChangedClaimsListResponsePort" message="os:GetChangedClaimsListResponseMsg" />
+			<fault name="ChangedClaimsListFault" message="os:ServiceFaultMsg" />
+		</operation>		
+		<operation name="declareEndpoint">
+			<input name="DeclareEndpointRequestPort" message="os:DeclareEndpointRequestMsg"/>
+			<output name="DeclareEndpointResponsePort" message="os:DeclareEndpointResponseMsg"/>
+			<fault name="DeclareEndpointFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="calculateKfz">
+			<input name="CalculateKfzRequestPort" message="os:CalculateKfzRequestMsg"/>
+			<output name="CalculateKfzResponsePort" message="os:CalculateKfzResponseMsg"/>
+			<fault name="CalculateKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createOfferKfz">
+			<input name="CreateOfferKfzRequestPort" message="os:CreateOfferKfzRequestMsg"/>
+			<output name="CreateOfferKfzResponsePort" message="os:CreateOfferKfzResponseMsg"/>
+			<fault name="CreateOfferKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createApplicationKfz">
+			<input name="CreateApplicationKfzRequestPort" message="os:CreateApplicationKfzRequestMsg"/>
+			<output name="CreateApplicationKfzResponsePort" message="os:CreateApplicationKfzResponseMsg"/>
+			<fault name="CreateApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<input name="SubmitApplicationKfzRequestPort" message="os:SubmitApplicationKfzRequestMsg"/>
+			<output name="SubmitApplicationKfzResponsePort" message="os:SubmitApplicationKfzResponseMsg"/>
+			<fault name="SubmitApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="getStateChanges">
+			<input name="GetStateChangesRequestPort" message="os:GetStateChangesRequestMsg"/>
+			<output name="GetStateChangesResponsePort" message="os:GetStateChangesResponseMsg"/>
+			<fault name="GetStateChangesFault" message="os:ServiceFaultMsg"/>
+		</operation>
+	
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+		
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+		
+		
+		<operation name="login">
+			<soap:operation soapAction="urn:login" style="document" />
+			<input name="loginRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="loginResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="loginFault">
+				<soap:fault name="loginFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getUserData">
+			<soap:operation soapAction="urn:getUserData" style="document" />
+			<input name="getUserDataRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getUserDataResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getUserDataFault">
+				<soap:fault name="getUserDataFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<soap:operation soapAction="urn:getOMDSPackageList" style="document" />
+			<input name="getOMDSPackageListRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageListResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageListFault">
+				<soap:fault name="getOMDSPackageListFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getOMDSPackage">
+			<soap:operation soapAction="urn:getOMDSPackage" style="document" />
+			<input name="getOMDSPackageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageFault">
+				<soap:fault name="getOMDSPackageFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<!-- Vertragsbezogene Dokumente ArcImage -->
+		
+		<operation name="getArcImageInfos">
+			<soap:operation soapAction="urn:getArcImageInfos" style="document" />
+			<input name="getArcImageInfosRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageInfosResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageInfosFault">
+				<soap:fault name="getArcImageInfosFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getArcImage">
+			<soap:operation soapAction="urn:getArcImage" style="document" />
+			<input name="getArcImageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageFault">
+				<soap:fault name="getArcImageFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<!-- Deep-Links -->
+		
+		<operation name="deepLinkClaim">
+			<soap:operation soapAction="urn:deepLinkClaim" style="document" />
+			<input name="deepLinkClaimRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkClaimResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkClaimFault">
+				<soap:fault name="deepLinkClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkPartner">
+			<soap:operation soapAction="urn:deepLinkPartner" style="document" />
+			<input name="deepLinkPartnerRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPartnerResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPartnerFault">
+				<soap:fault name="deepLinkPartnerFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkOffer">
+			<soap:operation soapAction="urn:deepLinkOffer" style="document" />
+			<input name="deepLinkOfferRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkOfferResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkOfferFault">
+				<soap:fault name="deepLinkOfferFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="deepLinkPolicy">
+			<soap:operation soapAction="urn:deepLinkPolicy" style="document" />
+			<input name="deepLinkPolicyRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPolicyResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPolicyFault">
+				<soap:fault name="deepLinkPolicyFault" use="literal"/>
+			</fault>
+		</operation>
+	
+		<!-- Schaden -->
+		<operation name="createClaim">
+			<soap:operation soapAction="urn:createClaim" style="document" />
+			<input name="CreateClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="CreateClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="CreateClaimFault">
+				<soap:fault name="CreateClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="initiateClaim">
+			<soap:operation soapAction="urn:initiateClaim" style="document" />
+			<input name="InitiateClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="InitiateClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="InitiateClaimFault">
+				<soap:fault name="InitiateClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+
+		<operation name="addDocToClaim">
+			<soap:operation soapAction="urn:addDocToClaim" style="document" />
+			<input name="AddDocToClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="AddDocToClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="AddDocToClaimFault">
+				<soap:fault name="AddDocToClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getClaim">
+			<soap:operation soapAction="urn:getClaim" style="document" />
+			<input name="GetClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimFault">
+				<soap:fault name="GetClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getClaimLight">
+			<soap:operation soapAction="urn:getClaimLight" style="document" />
+			<input name="GetClaimLightRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimLightResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimLightFault">
+				<soap:fault name="GetClaimLightFault" use="literal"/>
+			</fault>
+		</operation>
+				
+		<operation name="getNumberOfDocuments">
+			<soap:operation soapAction="urn:getNumberOfDocuments" style="document" />
+			<input name="GetNumberOfDocumentsRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetNumberOfDocumentsResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetNumberOfDocumentsFault">
+				<soap:fault name="GetNumberOfDocumentsFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getDocumentInfos">
+			<soap:operation soapAction="urn:getDocumentInfos" style="document" />
+			<input name="GetDocumentInfosRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentInfosResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentInfosFault">
+				<soap:fault name="GetDocumentInfosFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="searchClaim">
+			<soap:operation soapAction="urn:searchClaim" style="document" />
+			<input name="SearchClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SearchClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SearchClaimFault">
+				<soap:fault name="SearchClaimFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getLossEventList">
+			<soap:operation soapAction="urn:getLossEventList" style="document" />
+			<input name="LossEventListRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="LossEventListResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="LossEventListFault">
+				<soap:fault name="LossEventListFault" use="literal"/>
+			</fault>
+		</operation>
+		
+		<operation name="getChangedClaimsList">
+			<soap:operation soapAction="urn:getChangedClaimsList" style="document" />
+			<input name="ChangedClaimsListPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="ChangedClaimsListResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="ChangedClaimsListFault">
+				<soap:fault name="ChangedClaimsListFault" use="literal"/>
+			</fault>
+		</operation>
+	
+		<operation name="declareEndpoint">
+			<soap:operation soapAction="urn:declareEndpoint" style="document" />
+			<input name="DeclareEndpointRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="DeclareEndpointResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="DeclareEndpointFault">
+				<soap:fault name="DeclareEndpointFault" use="literal"/>
+			</fault>
+		</operation>
+		<!-- Berechnung, Offert, Antrag KFZ -->
+		<operation name="calculateKfz">
+			<soap:operation soapAction="urn:calculateKfz" style="document"/>
+			<input name="CalculateKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CalculateKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CalculateKfzFault">
+				<soap:fault name="CalculateKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createOfferKfz">
+			<soap:operation soapAction="urn:createOfferKfz" style="document"/>
+			<input name="CreateOfferKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateOfferKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateOfferKfzFault">
+				<soap:fault name="CreateOfferKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createApplicationKfz">
+			<soap:operation soapAction="urn:createApplicationKfz" style="document"/>
+			<input name="CreateApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateApplicationKfzFault">
+				<soap:fault name="CreateApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<soap:operation soapAction="urn:submitApplicationKfz" style="document"/>
+			<input name="SubmitApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="SubmitApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="SubmitApplicationKfzFault">
+				<soap:fault name="SubmitApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="getStateChanges">
+			<soap:operation soapAction="urn:getStateChanges" style="document"/>
+			<input name="GetStateChangesRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="GetStateChangesResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="GetStateChangesFault">
+				<soap:fault name="GetStateChangesFault" use="literal"/>
+			</fault>
+		</operation>
+		
+	</binding>
+	
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+	
+	
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy" 
+	    xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" 
+	    xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<!-- Beispiel fuer HTTPS: Erzwingt Ende-zu-Ende Verschluesselung -->
+				<!-- Dies muss allerdings nur aktiviert werden, wenn nicht andere Infrastruktur eine sichere Https-Verbindung gewaehrleistet -->
+				<sp:TransportBinding>
+					<wsp:Policy>
+						<sp:TransportToken>
+							<wsp:Policy>
+								<sp:HttpsToken RequireClientCertificate="false"/>
+							</wsp:Policy>
+						</sp:TransportToken>
+					</wsp:Policy>
+				</sp:TransportBinding>
+
+				<!-- Beispiel: Schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+				<sp:SupportingTokens>
+					<wsp:Policy>
+						<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+							<wsp:Policy>
+								<sp:HashPassword/>
+							</wsp:Policy>
+						</sp:UsernameToken>
+					</wsp:Policy>
+				</sp:SupportingTokens>
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+  
+
+</definitions>

client-lib/src/main/resources/def/r1_3_0/omds3ServicesBroker.wsdl

@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions 
+	name="omds3ServicesBroker-1-1-0" 
+	targetNamespace="urn:omds3ServicesBroker-1-1-0"
+	xmlns:os="urn:omds3ServicesBroker-1-1-0" 
+	xmlns:ost="urn:omds3ServiceTypes-1-1-0" 
+	xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" 
+	xmlns="http://schemas.xmlsoap.org/wsdl/"
+	xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:ns="http://www.w3.org/2001/XMLSchema"
+	xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+	
+	<!-- 
+	hier wird exampleVuServiceTypes.xsd referenziert, welches stellvertretend fuer eine individuelle
+	Erweiterung der omdsServiceTypes.xsd einer VU steht. So besteht die Möglichkeit die Requests und 
+	Responses um weitere Attribute zu erweitern 
+	-->
+	
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd" />
+		</schema>
+	</types>
+	
+	<!-- Schaden -->
+
+	
+	<message name="DeclareNewClaimStatusRequestMsg">
+		<part name="parameters" element="ost:DeclareNewClaimStatusRequest"/>
+	</message>
+	<message name="DeclareNewClaimStatusResponseMsg">
+		<part name="parameters" element="ost:DeclareNewClaimStatusResponse"/>
+	</message>
+
+	<message name="LossEventRegisteredRequestMsg">
+		<part name="parameters" element="ost:LossEventRegisteredRequest"/>
+	</message>
+	<message name="LossEventRegisteredResponseMsg">
+		<part name="parameters" element="ost:LossEventRegisteredResponse"/>
+	</message>
+
+	<!-- Vergabe eines Security Context Token 
+	<message name="SecurityContextTokenRequestMsg">
+		<part name="parameters" element="ost:SecurityContextTokenRequest"/>
+	</message>
+	<message name="SecurityContextTokenResponseMsg">
+		<part name="parameters" element="ost:SecurityContextTokenResponse" />
+	</message>		
+	-->
+
+	
+	<!-- Fehler Message -->	
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+	
+	
+	<portType name="omdsServicePortType">
+	
+		<!-- Schaden -->
+		<operation name="declareNewClaimStatus">
+			<input name="DeclareNewClaimStatusRequestPort" message="os:DeclareNewClaimStatusRequestMsg" />
+			<output name="DeclareNewClaimStatusResponsePort" message="os:DeclareNewClaimStatusResponseMsg" />
+            <fault name="DeclareNewClaimStatusFaultPort" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="lossEventRegistered">
+			<input name="LossEventRegisteredRequestPort" message="os:LossEventRegisteredRequestMsg" />
+			<output name="LossEventRegisteredResponsePort" message="os:LossEventRegisteredResponseMsg" />
+            <fault name="LossEventRegisteredFaultPort" message="os:ServiceFaultMsg" />
+        </operation>
+        
+<!--	Vergabe eines Security Context Token 
+		<operation name="getSecurityContextToken">
+			<input name="SecurityContextTokenRequestPort" message="os:SecurityContextTokenRequestMsg" />
+			<output name="SecurityContextTokenResponsePort" message="os:SecurityContextTokenResponseMsg" />
+			<fault name="SecurityContextTokenFaultPort" message="os:ServiceFaultMsg" />
+		</operation>
+-->
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+
+		<!-- Schaden -->
+		<operation name="declareNewClaimStatus">
+			<soap:operation soapAction="urn:declareNewClaimStatus" style="document" />
+			<input name="DeclareNewClaimStatusRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="DeclareNewClaimStatusResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="DeclareNewClaimStatusFaultPort">
+				<soap:fault name="DeclareNewClaimStatusFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="lossEventRegistered">
+			<soap:operation soapAction="urn:lossEventRegistered" style="document" />
+			<input name="LossEventRegisteredRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="LossEventRegisteredResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="LossEventRegisteredFaultPort">
+				<soap:fault name="LossEventRegisteredFault" use="literal"/>
+			</fault>
+		</operation>
+				
+		<!-- Vergabe eines Security Context Token 
+		<operation name="getSecurityContextToken">
+			<soap:operation soapAction="urn:getSecurityContextToken" style="document" />
+			<input name="SecurityContextTokenRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SecurityContextTokenResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SecurityContextTokenFaultPort">
+				<soap:fault name="SecurityContextTokenFault" use="literal"/>
+			</fault>
+		</operation>	
+		-->	
+	</binding>
+	
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+		
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy" 
+	  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	  xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+	  <wsp:ExactlyOne>
+		  <wsp:All>
+			<!-- Def HTTPS -->
+			<sp:TransportBinding>
+				<wsp:Policy>
+					<sp:TransportToken>
+						<wsp:Policy>
+							<sp:HttpsToken RequireClientCertificate="false"/>
+						</wsp:Policy>
+					</sp:TransportToken>
+				</wsp:Policy>
+			</sp:TransportBinding>
+			<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+			<sp:SupportingTokens>
+			  <wsp:Policy>
+				<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+				  <wsp:Policy>
+					<sp:HashPassword/>
+				  </wsp:Policy>
+				</sp:UsernameToken>
+			  </wsp:Policy>
+			</sp:SupportingTokens>
+
+		  </wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+  
+</definitions>

client-lib/src/main/resources/def/r1_3_0/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,276 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.3.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>State-Changes</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="GetStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjektes um Geschäftsfalle abzuholen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonSearchRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="GeschaeftsobjektArt" type="cst:GeschaeftsobjektArt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vorgabe einer Geschäftsobjektart, z.B. Vertrag, Schaden oder Antrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjektes um Geschäftsfalle abzuholen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonSearchResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Event" type="AbstractStateChangeEvent_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetStateChangesRequest" type="GetStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Abfrage von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetStateChangesResponse" type="GetStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Abfrage von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeclareStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die Bekanntgabe von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="StateChange" type="AbstractStateChangeEvent_Type" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="DeclareStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die Annahme von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:element name="DeclareStateChangesRequest" type="DeclareStateChangesRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Übermittlung von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="DeclareStateChangesResponse" type="DeclareStateChangesResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Übermittlung von Statusänderungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AbstractStateChangeEvent_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstraktes Event einer Statusänderung </xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="StateChangeEvent_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standard-Event einer Statusänderung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStateChangeEvent_Type">
+				<xsd:sequence>
+					<xsd:element name="Objektart" type="cst:GeschaeftsobjektArt_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Art des Objekts, z.B. Vertrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ObjektId" type="cst:ObjektId_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Id des Objekts als ObjektId_Type</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eine Geschäftsfall-Id als String, wenn dem Servicenutzer eine solche zugeordnet ist.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GeschaeftsfallArt" type="cst:GeschaeftsfallArt_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Art des Geschaeftsfalls der zur Statusänderung geführt hat.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Aenderungsdatum" type="omds:Datum-Zeit">
+						<xsd:annotation>
+							<xsd:documentation>Das Datum ab wann die Statusänderung feststeht.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="StatusGueltigAbDatum" type="omds:Datum-Zeit">
+						<xsd:annotation>
+							<xsd:documentation>Das Datum ab welchem die Statusänderung wirksam wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BisherigerStatus" type="AbstractStatusGeschaeftsfall_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional der bisherige Status</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="NeuerStatus" type="AbstractStatusGeschaeftsfall_Type">
+						<xsd:annotation>
+							<xsd:documentation>Der neue Status</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AbstractStatusGeschaeftsfall_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Status eines Geschaeftsfalls</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="StatusAntragsGeschaeftsfall">
+		<xsd:annotation>
+			<xsd:documentation>Status eines Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="AbstractStatusGeschaeftsfall_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+
+	<!-- Grundlagen Notifikationsservices -->
+	<xsd:element name="DeclareEndpointRequest" type="DeclareEndpointRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um als Makler der VU einen Endpoint bekannt zu geben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeclareEndpointRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den DeclareEndpointRequest</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="BasisUrlEndpoint">
+				<xsd:annotation>
+					<xsd:documentation>Die BasisURL unter welcher z.B. die VU die SOAP-Webservices des Vermittlers aufrufen kann. Die maximale Länge beträgt 1000 Zeichen</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1000"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element ref="ArtAuthentifizierung"/>
+			<xsd:element name="Credentials" type="Credentials_Type">
+				<xsd:annotation>
+					<xsd:documentation>Ein abstrakter Credentials-Type, für den z.B. der UsernamePasswordCredentials_Type eingesetzt werden kann.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AuthorizationFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die Zuordnung des Endpoints zu bestimmten fachlichen Nutzern, z.B. Vermittlernummern.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="ArtAuthentifizierung">
+		<xsd:annotation>
+			<xsd:documentation>Gibt vor, wie die Authentifizierung beim einzelnen Serviceaufruf erfolgt. Derzeit werden die Typen Username-Token und Security-Context-Token unterstützt.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:simpleType>
+			<xsd:restriction base="xsd:string">
+				<xsd:enumeration value="UsernameToken"/>
+				<xsd:enumeration value="Security-Context-Token"/>
+				<!--<xsd:enumeration value="Security-Context-Token"/> -->
+			</xsd:restriction>
+		</xsd:simpleType>
+	</xsd:element>
+	<xsd:complexType name="Credentials_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Ein abstrakter Typ, dessen konkrete Implementierungen unterschiedliche Credentials aufnehmen können. </xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="UsernamePasswordCredentials_Type">
+		<xsd:annotation>
+			<xsd:documentation>Konkrete Implementierung von Credentials mit Username und Password</xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="Username" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation>Der Username, wobei keine vorschriften bezüglich des Usernames gemacht werden.</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="Password" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation>Das Passwort, wobei keine Anforderungen an die Passwort-Stärke gemacht werden.</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<xsd:element name="DeclareEndpointResponse" type="DeclareEndpointResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response um als Makler der VU einen Endpoint bekannt zu geben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeclareEndpointResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response um als Makler der VU einen Endpoint bekannt zu geben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="RegistrierteBasisUrlMaklerEndpoint" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die von der VU zuletzt erfolgreich registrierte BasisUrl</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1000"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="SecurityContextTokenRequest" type="SecurityContextTokenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request zum Bezug eines Security-Context-Token</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SecurityContextTokenRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request-Type zum Bezug eines Security-Context-Tokens</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Credentials" type="Credentials_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="SecurityContextTokenResponse" type="SecurityContextTokenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response des Bezug eines Security-Context-Tokens</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SecurityContextTokenResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response-Type zum Bezug eines Securtity-Context-Tokens</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Token" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Der Token selbst als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="DauerhaftGueltig" type="xsd:boolean">
+				<xsd:annotation>
+					<xsd:documentation>Wahr, wenn der Token eine zeitlich unbeschränkte Gültigkeit aufweist, sonst falsch.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="GueltigBis" type="omds:Datum-Zeit" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Optional: Das Ablaufdatum des Tokens</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+
+
+</xsd:schema>

client-lib/src/main/resources/def/r1_3_0/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,270 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ost="urn:omds3ServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.3.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<!--Prozessobjekte Berechnung, Offert, Antrag - Spartenübergreifend-->
+	<xsd:complexType name="SpezBerechnung_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Berechnung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffert_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Offert, der bei Request und Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Offertnummer" type="cst:ObjektId_Type" minOccurs="0"/>
+			<xsd:element name="Personen" type="ost:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntrag_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Antragsart" type="cst:Antragsart_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die Antragsart kann auch vom ServiceProvider automatisch bestimmt werden, dann bleibt sie im Request leer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Personen" type="ost:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Vertragspersonen (nicht versicherte Personen), welche dann über ihre Rolle referenziert werden. Die Personen können eine Adresse enthalten.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbweichenderPraemienzahler" type="xsd:unsignedShort" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf einen abweichenden Praemienzahler, wenn nicht der Verisicherungsnehmer die Prämie zahlt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVersicherungsnehmer" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf weitere Versicherungsnehmer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVertragspersonen" type="cst:Vertragsperson_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Weitere Personen in Vertragsrollen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zahlungsdaten" type="cst:Zahlungsdaten_Type">
+				<xsd:annotation>
+					<xsd:documentation>Beschreibt die Art der Zahlung und enthält die zugehörigen Daten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Sepa" type="cst:SepaCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>SEPA-Mandat-Steuerung, wenn Zahlungsdaten ein SEPA-Mandat notwendig machen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Vinkulierung" type="cst:Vinkularglaeubiger_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Vinkulierungsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Polizzenversand" type="cst:PolizzenversandType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>alternativer Polizzenversand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Datenschutzbestimmungen" type="cst:Datenverwendung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Allgemeine Datenschutzbestimmungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Kontierung" type="cst:Kontierung_Type" minOccurs="0" maxOccurs="3"/>
+			<xsd:element name="ZusaetzlicheAntragsdaten" type="ZusaetzlicheAntragsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!--Abstrakte BOA-Operationstypen-->
+	<xsd:complexType name="CalculateRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="RequestUpselling" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation>Sollen Upselling-Vorschläge mitberechnet werden? Wenn ja kann dies zu einer längeren Berechnungsdauer führen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Ergebnis der Berechnung enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für das Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Offert enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Offertdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für den Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der den Antrag enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>optional ein aktueller Status des Antragsprozess</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn der Antrag fehlerfrei erstellt werden konnte, die Referenz auf diesen Antrag. Diese Referenz ist bei der Einreichung des Antrags anzugegeben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type">
+						<xsd:annotation>
+							<xsd:documentation>Die Referenz auf einen zuvor mit CreateApplication erzeugten Antrag, welcher jetzt eingereicht werden soll. Diese Referenz wird durch CreateApplication erzeugt. Ein Aufruf von CreateApplication ist notwendige Voraussetzung für den Aufruf von SubmitApplication</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>aktueller Status des eingespielten Antrages</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheAntragsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung des Antrags um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokumentId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>Eine DokumentenId als String</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokument" type="cst:DokumentInfo_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetApplicationDocumentRequest" type="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetApplicationDocumentResponse" type="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_3_0/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,579 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.3.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds29-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>Produktmodell Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="VerkaufsproduktKfz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Verkaufsprodukt_Type">
+				<xsd:sequence>
+					<xsd:element name="KfzVersicherung" type="ProduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="KfzZusatzVersicherung" type="ZusatzproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteFahrzeuge" type="cst:Fahrzeug_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>In Analogie zum OMDS-Datensatz befinden sich die Risikoobjekte als Element in der obersten Produktebene (OMDS Datensatz Element VERTRAG)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produkt, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element name="Haftpflicht" type="HaftpflichtKfz_Type"/>
+					<xsd:choice>
+						<xsd:element name="Teilkasko" type="TeilkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+						<xsd:element name="Vollkasko" type="VollkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:choice>
+					<xsd:element name="Insassenunfall" type="InsassenUnfallKfz_Type" minOccurs="0"/>
+					<xsd:element name="Assistance" type="AssistanceKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Zusatzprodukte, die mit einer KFZ-Versicherung gebündelt werden können.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="HaftpflichtKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Haftpflicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Haftpflicht erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element ref="omds:EL-Versicherungssumme">
+						<xsd:annotation>
+							<xsd:documentation>Versicherungssumme Haftpflicht</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VarianteLeihwagen" type="VarianteLeihwagen_Type"/>
+					<xsd:element ref="omds:EL-Einstufung"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="VDNummer" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="KaskoKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für die Kasko-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Teilkasko bzw. KFZ-Vollkasko erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SelbstbehaltBisBetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="KMLeistung" type="xsd:unsignedInt" minOccurs="0"/>
+					<xsd:element name="VorsteuerAbzugBerechtigung" type="xsd:boolean"/>
+					<xsd:element name="Vinkulierung" type="cst:Vinkulierung_Type" minOccurs="0"/>
+					<xsd:element name="Bezugsrecht" type="cst:Bezugsrecht_Type" minOccurs="0"/>
+					<!-- <xsd:element name="DatumBegutachtung" type="omds:Datum" minOccurs="0"/> -->
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Eingeschraenkt" type="xsd:boolean" default="0" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TeilkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Teilkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Vandalismusklausel" type="xsd:boolean"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VollkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Vollkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Neuwertklausel" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Leasingklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="InsassenUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Insassenunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="InsassenUnfallSystem" type="InsassenUnfallSystem_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LenkerUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Lenkerunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AssistanceKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Assistance</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="Zulassungsdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für Zulassungsdaten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VBNummer" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Versicherungsbestätigungsnummer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Kennzeichen" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zulassungs-Kennzeichen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Fahrgestellnummer" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zulassungs-Fahrgestellnummer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfzRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Kfz-Rechtsschutz-Versicherung, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkehrsrechtsschutz" type="VerkehrsrechtsschutzKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VerkehrsrechtsschutzKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Verkehrsrechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Typen für die BOA-Services fuer Kfz -->
+	<xsd:complexType name="SpezBerechnungKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antragsanfrage und Antragsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+					<xsd:element name="Ersatzpolizzennummer" type="cst:Ersatzpolizzen_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Ersatzpolizzennummern bei Konvertierung</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vorversicherungen" type="cst:Vorversicherungen_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bestehen Vorversicherungen zu dem Antrag</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BonusMalus" type="cst:BonusMalusSystem_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>BonusMalus beim Verband</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheKfzDaten" type="ZusaetzlicheKfzdaten_Type" minOccurs="0"/>
+					<xsd:element name="ZusendungWeitereDokumente" type="xsd:string" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Sollen weitere Antragsdokumente zugestellt werden</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingKfzResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Alternativen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="UpsellingVerkaufsprodukte" type="VerkaufsproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKfz_Type"/>
+					<xsd:element name="Zulassungsdaten" type="Zulassungsdaten_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Daten um das Fahrzeug in den Zulassungsdaten zu suchen. Ist die Zulassungsdaten Suche erfolgreich, werden die mitgeshickten Daten zwingend mit den Zulassungsdaten überschrieben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Berechnung die Details der Berechnung.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ResponseUpselling" type="UpsellingKfzResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Request für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertKfz_Type"/>
+					<xsd:element name="Zulassungsdaten" type="Zulassungsdaten_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Daten um das Fahrzeug in den Zulassungsdaten zu suchen. Ist die Zulassungsdaten Suche erfolgreich, werden die mitgeshickten Daten zwingend mit den Zulassungsdaten überschrieben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Response für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Erstellung eines Offerts.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="SpezOffertKfz_Type"/>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type"/>
+					<xsd:element name="Zulassungsdaten" type="Zulassungsdaten_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Daten um das Fahrzeug in den Zulassungsdaten zu suchen. Ist die Zulassungsdaten Suche erfolgreich, werden die mitgeshickten Daten zwingend mit den Zulassungsdaten überschrieben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequest_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Hier werden nochmals alle Antragsdaten zur Verfügung gestellt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Konkrete Services (Request- und Responseobjekte) Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="CalculateKfzRequest" type="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Kfz Berechnung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateKfzResponse" type="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzRequest" type="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Kfz Offert</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzResponse" type="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offert Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzRequest" type="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für einen Kfz Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzResponse" type="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antrag Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzRequest" type="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzResponse" type="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="FahrzeugRefLfdNr" type="xsd:string">
+		<xsd:annotation>
+			<xsd:documentation>Refernziert auf ein versichertes Fahrzeug über die laufende Nummer innerhalb eines Elementarprodukts.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:simpleType name="InsassenUnfallSystem_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type System Insassenunfallversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Pauschalsystem"/>
+			<xsd:enumeration value="Platzsystem1"/>
+			<xsd:enumeration value="Platzsystem2"/>
+			<xsd:enumeration value="Personensystem"/>
+			<xsd:enumeration value="Lenkerunfallversicherung"/>
+			<xsd:enumeration value="Aufsassenunfallversicherung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="VarianteLeihwagen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Variante Leihwagen (A, B)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="VA">
+				<xsd:annotation>
+					<xsd:documentation>ohne Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VB">
+				<xsd:annotation>
+					<xsd:documentation>mit Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Zusätzliche KFZ-Daten -->
+	<xsd:complexType name="ZusaetzlicheKfzdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zusätzliche Kfz-Daten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="KfzKennzeichen">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="3"/>
+						<xsd:maxLength value="9"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="VvdVertrag" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="Fahrgestellnummer" type="Fahrgestellnummer_Type"/>
+			<xsd:element name="ErfolgtAnmeldungZeitgleichMitAbmeldung" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="AbmeldedatumWechselkennzeichenFahrzeug" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="Wechselkennzeichen" type="Wechselkennzeichen_Type" minOccurs="0"/>
+			<xsd:element name="Fahrzeugzustand" type="Fahrzeugzustand_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Wechselkennzeichen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Wechselkennzeichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="WechselkennzeichenArt">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Neues Fahrzeug als WKZ in bestehenden Vertrag einbündeln"/>
+						<xsd:enumeration value="Fahrzeugwechsel im bestehenden WKZ-Vertrag"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="BestehenderWechselkennzeichenvertrag" type="xsd:string"/>
+			<xsd:element name="ErsetztWirdFahrgestellnummer" type="Fahrgestellnummer_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="Fahrgestellnummer_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Fahrgestellnummer FIN</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="30"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="Fahrzeugzustand_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Abbildung Fahrzeugzustand</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ZustandsberichtLiegtAlsFormularBei" type="xsd:boolean" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zustandsbericht liegt als Formular bei bzw. Besichtigung durch externe Stelle veranlasst - muss dann als Attachment mitgeschickt werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zustandsbeschreibung" type="Zustandsbeschreibung_Type"/>
+			<xsd:element name="SchaedenAnScheibenKleinglas" type="SchaedenAnScheibenKleinglas_Type" minOccurs="0"/>
+			<xsd:element name="SchaedenAmFahrzeug" type="SchaedenAmFahrzeug_Type" minOccurs="0"/>
+			<xsd:element name="KilometerLtBesichtigung" type="xsd:integer" minOccurs="0"/>
+			<xsd:element name="Vorschaeden" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsort" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsdatum" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="GrundFuerNachbesichtigung" type="xsd:string" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="Zustandsbeschreibung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Zustandsbeschreibung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Besichtigung durch Betreuer"/>
+			<xsd:enumeration value="Kaufvertrag eines Markenhändlers mit Beschreibung (Kopie erforderlich)"/>
+			<xsd:enumeration value="Besichtigung durch ÖAMTC"/>
+			<xsd:enumeration value="Nachbesichtigung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAnScheibenKleinglas_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Beschreibung Schäden an Kleinglas</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an Scheiben / Kleinglas"/>
+			<xsd:enumeration value="Schäden an Scheiben / Kleinglas"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAmFahrzeug_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Schäden am Fahrzeug</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an der Karosserie"/>
+			<xsd:enumeration value="Schäden an der Karosserie"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_4_0/omds3ServiceTypes.xsd

@@ -0,0 +1,681 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3ServiceTypes-1-1-0" xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:omds3ServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.4.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<!-- Beziehe Action Link -->
+	<xsd:element name="loginRequest" type="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt für den Actionlink</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ des Request-Objekts fuer den allgemeinen Portaleinstieg</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="loginResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Der Actionlink z.B. in das Maklerportal mit einem Token, der die Verbindung zur Session herstellt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<!-- Beziehe User-Daten -->
+	<xsd:element name="getUserDataRequest" type="UserDataRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt fuer den Zugriff auf die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die VUNr des angefragten Unternehmens. Dies ermöglicht ggf. mehrere VUs über eine technische Lösung zu servicieren. Verwendet den Typ VUNr aus OMDS-Datensatz.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getUserDataResponse" type="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Das Ergebnisobjekt fuer die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Type mit Benutzerinformationen. Das Element 'address' ist mit Version 1.1.0 entfallen, da diese Informationen auch im Element 'person' übermittelt werden können
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="userid">
+				<xsd:annotation>
+					<xsd:documentation>BenutzerId</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="availableServices">
+				<xsd:annotation>
+					<xsd:documentation>Liste der für diesen User unterstützen Services</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="service" type="xsd:string" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Die ServiceId des jeweiligen Webservice als String</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="person" type="omds:PERSON_Type">
+				<xsd:annotation>
+					<xsd:documentation>Ist vom Typ PERSON_Type aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste verfuegbarer OMDS-Datensaetze -->
+	<xsd:element name="getOMDSPackageListRequest" type="OMDSPackageListRequest">
+		<xsd:annotation>
+			<xsd:documentation>Inputobjekt zum Beziehen einer Liste verfuegbarer OMDS-Datensaetze</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>die VUNr aus OMDS als optionaler Filterparameter</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>von inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>bis inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageListResponse" type="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabeobjekt für eine Liste von OMDS-Datensätzen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine Liste von OMDS-Datensaetzen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence minOccurs="0">
+			<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" minOccurs="0" maxOccurs="unbounded"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe einzelnen OMDS-Datensatz -->
+	<xsd:element name="getOMDSPackageRequest" type="OMDSPackageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Requestobjekt fuer die Abholung eines oder mehrerer OMDS-Datensatz-Packages</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageId" type="xsd:string" nillable="false" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Datensatzes unter welcher er ueber Webservices referenziert werden kann. Es handelt sich nicht um eine Id aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageResponse" type="OMDSPackageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Gibt die Liste der angeforderten OMDS-Packages zurück oder entsprechende fachliche Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageResponse">
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackage" type="RequestedOMDSPackage" nillable="false" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste der angeforderten Pakete</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="RequestedOMDSPackage">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer ein OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackageId" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Die angefragte Id des OMDS-Datenpakets, wobei dies kein Schlüssel aus dem Paket ist. </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="omdsPackage" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Nur enthalten, wenn es das angeforderte Paket tatsächlich gibt und der User darauf berechtigt ist.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" nillable="false">
+							<xsd:annotation>
+								<xsd:documentation>Meta-Informationen zu diesem Paket</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="content" type="xsd:base64Binary" xmime:expectedContentTypes="application/zip">
+							<xsd:annotation>
+								<xsd:documentation>Gezippte OMDS-Daten als base64Binary oder mit Binary mit MTOM</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="OMDSPackageInfoType">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die wesentlichen Informationen zu einem OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="MaklerID" type="cst:MaklerID_Type" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Entspricht der MaklerID in OMDS 2.x. Die MaklerID (in Version 1.0.0 noch AgentID) ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für die jeweilige VU oder den jeweiligen Dienstleister, bei dem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die agentID mit der Vermittlernummer "Vermnr" (in Version 1.0.0 noch agentNumber) zusammenfällt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des OMDS Pakets und Angaben zu ihrer Verwendbarkeit, wobei hier kein Schlüssel aus einem OMDS Paket selbst gemeint ist, sondern eine eigenständige Id, die das Abrufen des OMDS-Pakets ermöglicht.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="timeStamp" type="omds:Datum-Zeit" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Zeitstempel der Erstellung entsprechend dem Attribut PaketZpktErstell mit OMDS Datum-Zeit als Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageSize" type="xsd:int" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Groesse der Datei in Byte, de facto beschränkt auf max. ca. 2 GB da vom Typ int</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageExtent" type="omds:PaketUmfCd_Type">
+				<xsd:annotation>
+					<xsd:documentation>entspricht dem der Paketumfang wie er in OMDS 2.x im Typ PaketUmfCd_Type definiert ist: D = Differenz, G = Gesamtbestand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageContentCode" type="omds:PaketInhCd_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste von OMDS 2.x Elementen des Typs PaketInhCd_Type, die den Inhalt des Datenpakets beschreiben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste vertragsbezogener Dokumente -->
+	<xsd:element name="getArcImageInfosRequest" type="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfrage Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfragetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>die Polizzennummer als OMDS Polizzennr-Typ.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyType" type="omds:VtgProdCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für Polizzen eines bestimmten Typs. Das Attribut ist vom Typ VtgProdCd_Type des OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyPartnerRole" type="PolicyPartnerRole" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für bestimmte Partner in einer bestimmten Rolle</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf bestimmte Dokumententypen. Es gibt 15 definierte vertragsbezogene Dokumententypen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageInfosResponse" type="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabe Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Informationen zu Dokumenten, wenn vorhanden</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageRequest" type="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requesttyp zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArcImageId">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Dokuments vom Typ String</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<!--<xsd:element name="policy" type="Policy"/>-->
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageResponse" type="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responsetyp zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ArcContent" type="ArcContent" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Das Dokument und seine Meta-Informationen, wenn ein Dokument vorhanden war</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="PolicyPartnerRole">
+		<xsd:annotation>
+			<xsd:documentation>Partnerrollen in einer Polizze: Versicherungsnehmer, Versicherte Person</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS-Personennr (String mit 1-26 Zeichen) </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="partnerRole" type="cst:PartnerRoleType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Partnerrollen im Vertrag als PartnerRoleType: String mit 2 Zeichen: VN, VP</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcImageInfo">
+		<xsd:annotation>
+			<xsd:documentation>Information zu einem einzelnen Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Dokuments und Details zur Verwendung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="name" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Der Name des Dokuments als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType">
+				<xsd:annotation>
+					<xsd:documentation>Der inhaltliche Typ des Dokuments, z.B. "Polizze" oder "Finanzamtsbestätigung" als Integer-Code</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentType" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mime-Type des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentLength" type="xsd:long" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Größe des Dokuments in Byte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="date" type="xsd:date">
+				<xsd:annotation>
+					<xsd:documentation>Erstellungsdatum des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="docReference" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Verweis auf weitere Dokumente, die inhaltlich zu diesem Dokument gehören, z.B. AVB zu einer Polizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcContent">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument und das Dokument base64encoded</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo">
+				<xsd:annotation>
+					<xsd:documentation>Meta-Informationen zum Dokument</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcImage" type="xsd:base64Binary" xmime:expectedContentTypes="application/octet-stream">
+				<xsd:annotation>
+					<xsd:documentation>Das eigentliche Dokument als base64-Binary</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe Deep-Links -->
+	<xsd:element name="getDeepLinkClaimRequest" type="DeepLinkClaimRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Schaden Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkClaimRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="claimNumber" type="omds:Schadennr">
+				<xsd:annotation>
+					<xsd:documentation>Schadennummer vom Typ OMDS Schadennr</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkClaimResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt Deep-Link Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPartnerRequest" type="DeepLinkPartnerRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPartnerRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS Personennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPartnerResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkOfferRequest" type="DeepLinkOfferRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot/ Antrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkOfferRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="offerNumber" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer der Berechnung, des Angebots oder des Antrags.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkOfferResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot / Antrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPolicyRequest" type="DeepLinkPolicyRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPolicyRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer des Vertrags als OMDS Polizzennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPolicyResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkBusinessObjectResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Deep-Link auf Geschäftsobjekte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="withoutFrame" type="xsd:boolean">
+		<xsd:annotation>
+			<xsd:documentation>Soll ein Frame angezeigt werden oder nicht</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="httpActionLink" type="HttpActionLinkType"/>
+	<xsd:complexType name="HttpActionLinkType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen Deep-Link</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="url">
+				<xsd:annotation>
+					<xsd:documentation>String mit max. 1024 Zeichen</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="type">
+				<xsd:annotation>
+					<xsd:documentation>Code für Art der URL, z.B. Verträge, Dokumente, Schäden, Schadenmeldung als int-Type.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:int">
+						<xsd:enumeration value="1">
+							<xsd:annotation>
+								<xsd:documentation>Einstiegsseite</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="2">
+							<xsd:annotation>
+								<xsd:documentation>Suche Partner</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="3">
+							<xsd:annotation>
+								<xsd:documentation>Suche Vertrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="4">
+							<xsd:annotation>
+								<xsd:documentation>Suche Schaden</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="5">
+							<xsd:annotation>
+								<xsd:documentation>Suche Angebot/Antrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="6">
+							<xsd:annotation>
+								<xsd:documentation>Schadenübersicht</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden, keine Doublette zu Nr 12, da hier Übersicht über einzelnen Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="7">
+							<xsd:annotation>
+								<xsd:documentation>Dokumente</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="8">
+							<xsd:annotation>
+								<xsd:documentation>Anfrage</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="9">
+							<xsd:annotation>
+								<xsd:documentation>Stammdaten</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="10">
+							<xsd:annotation>
+								<xsd:documentation>Bearbeiten</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="11">
+							<xsd:annotation>
+								<xsd:documentation>Verträge</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="12">
+							<xsd:annotation>
+								<xsd:documentation>Schäden</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, Keine Doublette zu Nr 6 da hier eine Liste von Schäden zu einem gegebenen Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="13">
+							<xsd:annotation>
+								<xsd:documentation>Angebote</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner, keine Doublette zu Nr 14 Angebots-/ Antragsübersicht, da hier nur Angebote des Partners -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="14">
+							<xsd:annotation>
+								<xsd:documentation>Angebots-/ Antragsübersicht</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, keine Doublette zu Nr 13, da hier Übersichtsseite über alle Angebote/ Anträge des Service-Konsumenten -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="15">
+							<xsd:annotation>
+								<xsd:documentation>Inkassostand</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="16">
+							<xsd:annotation>
+								<xsd:documentation>Angebot</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="17">
+							<xsd:annotation>
+								<xsd:documentation>Schadenmeldung</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="18">
+							<xsd:annotation>
+								<xsd:documentation>Mahnungen</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="validUntil" type="xsd:dateTime" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ablaufzeitpunkt der Action-Links. Wenn Actionslinks vorhanden sind, dieses Element jedoch nicht oder mit dem Wert "null", so sind die ActionLinks zeitlich unbeschränkt gültig. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="DeepLinkBusinessObjectResponse">
+		<xsd:sequence>
+			<xsd:element name="httpActionLink" type="HttpActionLinkType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Linkbeschreibung vom Typ LinkType</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_4_0/omds3Services.wsdl

@@ -0,0 +1,526 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Release 1.4.0 -->
+<definitions name="omds3Services-1-1-0" targetNamespace="urn:omds3Services-1-1-0"
+xmlns:os="urn:omds3Services-1-1-0"
+xmlns:ost="urn:omds3ServiceTypes-1-1-0"
+xmlns:cst="urn:omds3CommonServiceTypes-1-1-0"
+xmlns:b="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen"
+xmlns:boak="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz"
+xmlns="http://schemas.xmlsoap.org/wsdl/"
+xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
+xmlns:ns="http://www.w3.org/2001/XMLSchema"
+xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/"
+xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+	<!-- 
+	hier wird exampleVuServiceTypes.xsd referenziert, welches stellvertretend fuer eine individuelle
+	Erweiterung der omdsServiceTypes.xsd einer VU steht. So besteht die Möglichkeit die Requests und 
+	Responses um weitere Attribute zu erweitern 
+	-->
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" schemaLocation="omds3_ON1_Basisfunktionen.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" schemaLocation="omds3_ON2_Antrag_Kfz.xsd"/>
+		</schema>
+	</types>
+	<message name="loginRequest">
+		<part name="parameters" element="ost:loginRequest"/>
+	</message>
+	<message name="loginResponse">
+		<part name="parameters" element="ost:loginResponse"/>
+	</message>
+
+	<message name="getUserDataRequest">
+		<part name="parameters" element="ost:getUserDataRequest"/>
+	</message>
+	<message name="getUserDataResponse">
+		<part name="parameters" element="ost:getUserDataResponse"/>
+	</message>
+
+	<message name="getOMDSPackageListRequest">
+		<part name="parameters" element="ost:getOMDSPackageListRequest"/>
+	</message>
+	<message name="getOMDSPackageListResponse">
+		<part name="parameters" element="ost:getOMDSPackageListResponse" />
+	</message>
+
+	<message name="getOMDSPackageRequest">
+		<part name="parameters" element="ost:getOMDSPackageRequest"/>
+	</message>
+	<message name="getOMDSPackageResponse">
+		<part name="parameters" element="ost:getOMDSPackageResponse" />
+	</message>
+
+	<!-- Vertragsbezogene Dokumente -->
+
+	<message name="getArcImageInfosRequest">
+		<part name="parameters" element="ost:getArcImageInfosRequest"/>
+	</message>
+	<message name="getArcImageInfosResponse">
+		<part name="parameters" element="ost:getArcImageInfosResponse" />
+	</message>
+	<message name="getArcImageRequest">
+		<part name="parameters" element="ost:getArcImageRequest"/>
+	</message>
+	<message name="getArcImageResponse">
+		<part name="parameters" element="ost:getArcImageResponse" />
+	</message>
+
+	<!-- Auskunft ueber Dokumente -->
+	<message name="GetNumberOfDocumentsRequestMsg">
+		<part name="parameters" element="b:GetNumberOfDocumentsRequest"/>
+	</message>
+	<message name="GetNumberOfDocumentsResponseMsg">
+		<part name="parameters" element="b:GetNumberOfDocumentsResponse" />
+	</message>
+	<message name="GetDocumentsOfObjectRequestMsg">
+		<part name="parameters" element="b:GetDocumentsOfObjectRequest"/>
+	</message>
+	<message name="GetDocumentsOfObjectResponseMsg">
+		<part name="parameters" element="b:GetDocumentsOfObjectResponse" />
+	</message>
+	<message name="GetDocumentsOfPeriodRequestMsg">
+		<part name="parameters" element="b:GetDocumentsOfPeriodRequest"/>
+	</message>
+	<message name="GetDocumentsOfPeriodResponseMsg">
+		<part name="parameters" element="b:GetDocumentsOfPeriodResponse" />
+	</message>
+
+	<!-- Deep Links -->
+
+	<message name="deepLinkClaimRequest">
+		<part name="parameters" element="ost:getDeepLinkClaimRequest"/>
+	</message>
+	<message name="deepLinkClaimResponse">
+		<part name="parameters" element="ost:getDeepLinkClaimResponse" />
+	</message>
+
+	<message name="deepLinkPartnerRequest">
+		<part name="parameters" element="ost:getDeepLinkPartnerRequest"/>
+	</message>
+	<message name="deepLinkPartnerResponse">
+		<part name="parameters" element="ost:getDeepLinkPartnerResponse" />
+	</message>
+	<message name="deepLinkOfferRequest">
+		<part name="parameters" element="ost:getDeepLinkOfferRequest"/>
+	</message>
+	<message name="deepLinkOfferResponse">
+		<part name="parameters" element="ost:getDeepLinkOfferResponse" />
+	</message>
+	<message name="deepLinkPolicyRequest">
+		<part name="parameters" element="ost:getDeepLinkPolicyRequest"/>
+	</message>
+	<message name="deepLinkPolicyResponse">
+		<part name="parameters" element="ost:getDeepLinkPolicyResponse" />
+	</message>
+
+	
+	<!-- Kraftfahrt -->
+	<message name="CalculateKfzRequestMsg">
+		<part name="parameters" element="boak:CalculateKfzRequest"/>
+	</message>
+	<message name="CalculateKfzResponseMsg">
+		<part name="parameters" element="boak:CalculateKfzResponse"/>
+	</message>
+	<message name="CreateOfferKfzRequestMsg">
+		<part name="parameters" element="boak:CreateOfferKfzRequest"/>
+	</message>
+	<message name="CreateOfferKfzResponseMsg">
+		<part name="parameters" element="boak:CreateOfferKfzResponse"/>
+	</message>
+	<message name="CreateApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzRequest"/>
+	</message>
+	<message name="CreateApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzResponse"/>
+	</message>
+	<message name="SubmitApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzRequest"/>
+	</message>
+	<message name="SubmitApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzResponse"/>
+	</message>
+	
+	<!-- Fehler -->
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+
+
+	<portType name="omdsServicePortType">
+
+		<operation name="login">
+			<input name="loginRequest" message="os:loginRequest" />
+			<output name="loginResponse" message="os:loginResponse" />
+            <fault name="loginFault" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="getUserData">
+			<input name="getUserDataRequest" message="os:getUserDataRequest" />
+			<output name="getUserDataResponse" message="os:getUserDataResponse" />
+			<fault name="getUserDataFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<input name="getOMDSPackageListRequest" message="os:getOMDSPackageListRequest" />
+			<output name="getOMDSPackageListResponse" message="os:getOMDSPackageListResponse" />
+			<fault name="getOMDSPackageListFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<input name="getOMDSPackageRequest" message="os:getOMDSPackageRequest" />
+			<output name="getOMDSPackageResponse" message="os:getOMDSPackageResponse" />
+			<fault name="getOMDSPackageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImageInfos">
+			<input name="getArcImageInfosRequest" message="os:getArcImageInfosRequest" />
+			<output name="getArcImageInfosResponse" message="os:getArcImageInfosResponse" />
+			<fault name="getArcImageInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImage">
+			<input name="getArcImageRequest" message="os:getArcImageRequest" />
+			<output name="getArcImageResponse" message="os:getArcImageResponse" />
+			<fault name="getArcImageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkClaim">
+			<input name="deepLinkClaimRequest" message="os:deepLinkClaimRequest" />
+			<output name="deepLinkClaimResponse" message="os:deepLinkClaimResponse" />
+			<fault name="deepLinkClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<input name="deepLinkPartnerRequest" message="os:deepLinkPartnerRequest" />
+			<output name="deepLinkPartnerResponse" message="os:deepLinkPartnerResponse" />
+			<fault name="deepLinkPartnerFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<input name="deepLinkOfferRequest" message="os:deepLinkOfferRequest" />
+			<output name="deepLinkOfferResponse" message="os:deepLinkOfferResponse" />
+			<fault name="deepLinkOfferFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<input name="deepLinkPolicyRequest" message="os:deepLinkPolicyRequest" />
+			<output name="deepLinkPolicyResponse" message="os:deepLinkPolicyResponse" />
+			<fault name="deepLinkPolicyFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getNumberOfDocuments">
+			<input name="GetNumberOfDocumentsRequestPort" message="os:GetNumberOfDocumentsRequestMsg" />
+			<output name="GetNumberOfDocumentsResponsePort" message="os:GetNumberOfDocumentsResponseMsg" />
+			<fault name="GetNumberOfDocumentsFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentsOfObject">
+			<input name="GetDocumentsOfObjectRequestPort" message="os:GetDocumentsOfObjectRequestMsg" />
+			<output name="GetDocumentsOfObjectResponsePort" message="os:GetDocumentsOfObjectResponseMsg" />
+			<fault name="GetDocumentsOfObjectFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentsOfPeriod">
+			<input name="GetDocumentsOfPeriodRequestPort" message="os:GetDocumentsOfPeriodRequestMsg" />
+			<output name="GetDocumentsOfPeriodResponsePort" message="os:GetDocumentsOfPeriodResponseMsg" />
+			<fault name="GetDocumentsOfPeriodFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="calculateKfz">
+			<input name="CalculateKfzRequestPort" message="os:CalculateKfzRequestMsg"/>
+			<output name="CalculateKfzResponsePort" message="os:CalculateKfzResponseMsg"/>
+			<fault name="CalculateKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createOfferKfz">
+			<input name="CreateOfferKfzRequestPort" message="os:CreateOfferKfzRequestMsg"/>
+			<output name="CreateOfferKfzResponsePort" message="os:CreateOfferKfzResponseMsg"/>
+			<fault name="CreateOfferKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createApplicationKfz">
+			<input name="CreateApplicationKfzRequestPort" message="os:CreateApplicationKfzRequestMsg"/>
+			<output name="CreateApplicationKfzResponsePort" message="os:CreateApplicationKfzResponseMsg"/>
+			<fault name="CreateApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<input name="SubmitApplicationKfzRequestPort" message="os:SubmitApplicationKfzRequestMsg"/>
+			<output name="SubmitApplicationKfzResponsePort" message="os:SubmitApplicationKfzResponseMsg"/>
+			<fault name="SubmitApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+
+
+		<operation name="login">
+			<soap:operation soapAction="urn:login" style="document" />
+			<input name="loginRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="loginResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="loginFault">
+				<soap:fault name="loginFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getUserData">
+			<soap:operation soapAction="urn:getUserData" style="document" />
+			<input name="getUserDataRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getUserDataResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getUserDataFault">
+				<soap:fault name="getUserDataFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<soap:operation soapAction="urn:getOMDSPackageList" style="document" />
+			<input name="getOMDSPackageListRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageListResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageListFault">
+				<soap:fault name="getOMDSPackageListFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<soap:operation soapAction="urn:getOMDSPackage" style="document" />
+			<input name="getOMDSPackageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageFault">
+				<soap:fault name="getOMDSPackageFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Vertragsbezogene Dokumente ArcImage -->
+
+		<operation name="getArcImageInfos">
+			<soap:operation soapAction="urn:getArcImageInfos" style="document" />
+			<input name="getArcImageInfosRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageInfosResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageInfosFault">
+				<soap:fault name="getArcImageInfosFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getArcImage">
+			<soap:operation soapAction="urn:getArcImage" style="document" />
+			<input name="getArcImageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageFault">
+				<soap:fault name="getArcImageFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Deep-Links -->
+
+		<operation name="deepLinkClaim">
+			<soap:operation soapAction="urn:deepLinkClaim" style="document" />
+			<input name="deepLinkClaimRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkClaimResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkClaimFault">
+				<soap:fault name="deepLinkClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<soap:operation soapAction="urn:deepLinkPartner" style="document" />
+			<input name="deepLinkPartnerRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPartnerResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPartnerFault">
+				<soap:fault name="deepLinkPartnerFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<soap:operation soapAction="urn:deepLinkOffer" style="document" />
+			<input name="deepLinkOfferRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkOfferResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkOfferFault">
+				<soap:fault name="deepLinkOfferFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<soap:operation soapAction="urn:deepLinkPolicy" style="document" />
+			<input name="deepLinkPolicyRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPolicyResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPolicyFault">
+				<soap:fault name="deepLinkPolicyFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Dokumentenhandling -->
+
+		<operation name="getNumberOfDocuments">
+			<soap:operation soapAction="urn:getNumberOfDocuments" style="document" />
+			<input name="GetNumberOfDocumentsRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetNumberOfDocumentsResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetNumberOfDocumentsFault">
+				<soap:fault name="GetNumberOfDocumentsFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- in 1.3 noch getDocumentInfos wurde aufgetrennt in getDocumentsOfObject und getDocumentsOfPeriod -->
+		<operation name="getDocumentsOfObject">
+			<soap:operation soapAction="urn:getDocumentsOfObject" style="document" />
+			<input name="GetDocumentsOfObjectRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentsOfObjectResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentsOfObjectFault">
+				<soap:fault name="GetDocumentsOfObjectFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getDocumentsOfPeriod">
+			<soap:operation soapAction="urn:getDocumentsOfPeriod" style="document" />
+			<input name="GetDocumentsOfPeriodRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentsOfPeriodResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentsOfPeriodFault">
+				<soap:fault name="GetDocumentsOfPeriodFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Berechnung, Offert, Antrag KFZ -->
+		<operation name="calculateKfz">
+			<soap:operation soapAction="urn:calculateKfz" style="document"/>
+			<input name="CalculateKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CalculateKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CalculateKfzFault">
+				<soap:fault name="CalculateKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createOfferKfz">
+			<soap:operation soapAction="urn:createOfferKfz" style="document"/>
+			<input name="CreateOfferKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateOfferKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateOfferKfzFault">
+				<soap:fault name="CreateOfferKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createApplicationKfz">
+			<soap:operation soapAction="urn:createApplicationKfz" style="document"/>
+			<input name="CreateApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateApplicationKfzFault">
+				<soap:fault name="CreateApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<soap:operation soapAction="urn:submitApplicationKfz" style="document"/>
+			<input name="SubmitApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="SubmitApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="SubmitApplicationKfzFault">
+				<soap:fault name="SubmitApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+	</binding>
+
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+
+
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy"
+	    xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	    xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<!-- Def HTTPS: Erzwingt Ende-zu-Ende Verschluesselung -->
+				<!-- Dies muss allerdings nur aktiviert werden, wenn nicht andere Infrastruktur eine sichere Https-Verbindung gewaehrleistet -->
+				<sp:TransportBinding>
+					<wsp:Policy>
+						<sp:TransportToken>
+							<wsp:Policy>
+								<sp:HttpsToken RequireClientCertificate="false"/>
+							</wsp:Policy>
+						</sp:TransportToken>
+					</wsp:Policy>
+				</sp:TransportBinding>
+
+				<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+				<sp:SupportingTokens>
+					<wsp:Policy>
+						<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+							<wsp:Policy>
+								<sp:HashPassword/>
+							</wsp:Policy>
+						</sp:UsernameToken>
+					</wsp:Policy>
+				</sp:SupportingTokens>
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+
+</definitions>

client-lib/src/main/resources/def/r1_4_0/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.4.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:element name="GetNumberOfDocumentsRequest" type="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Anzahl von Dokumenten zu einem fachlichen Objekt zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ enthält die Elemente fuer die Anfrage nach Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type">
+				<xsd:annotation>
+					<xsd:documentation>ObjektSpezifikation kann ab Version 1.3 entfallen, es kann aber sein, dass das Versicherungsunternehmen einen Fehler meldet, weil es Anfragen nur mit Objektspezifikation unterstützt oder weil die Ergebnismenge zu groß wäre.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsResponse" type="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response mit einer Anzahl von Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="AnzDokumente" type="xsd:nonNegativeInteger"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectRequest" type="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines fachlichen Objekts zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectResponse" type="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodRequest" type="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines Zeitraums zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type" minOccurs="0"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodResponse" type="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:complexType name="DocumentInfosResponseResult_Type">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ActualOffset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Der tatsächliche Offset in der  Ergebnisliste.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ActualMaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Tatsächliche Maximalanzahl der Ergebnisse, die der Provider auf eine Anfrage zurück gibt. Beispiel: Consumer fordert 1000 Ergebnisse an, Provider liefert aber maximal 100 zurück. In diesem Fall würde hier 100 zurückgegeben. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="TotalResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Gesamtzahl der Dokumente unter dem gewählten Filter.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="DokumentInfos" type="cst:DokumentenReferenz_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_4_0/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,295 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ost="urn:omds3ServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.4.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<!--Prozessobjekte Berechnung, Offert, Antrag - Spartenübergreifend-->
+	<xsd:complexType name="SpezBerechnung_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Berechnung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffert_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Offert, der bei Request und Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Offertnummer" type="cst:ObjektId_Type" minOccurs="0"/>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntrag_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Antragsart" type="cst:Antragsart_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die Antragsart kann auch vom ServiceProvider automatisch bestimmt werden, dann bleibt sie im Request leer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Vertragspersonen (nicht versicherte Personen), welche dann über ihre Rolle referenziert werden. Die Personen können eine Adresse enthalten.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbweichenderPraemienzahler" type="xsd:unsignedShort" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf einen abweichenden Praemienzahler, wenn nicht der Verisicherungsnehmer die Prämie zahlt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVersicherungsnehmer" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf weitere Versicherungsnehmer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVertragspersonen" type="cst:Vertragsperson_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Weitere Personen in Vertragsrollen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbgelehnteRisiken" type="cst:AbgelehnteRisiken_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Bestehen Ablehnungen zu den beantragten Risiken</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Vorversicherungen" type="cst:Vorversicherungen_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Bestehen Vorversicherungen zu dem Antrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zahlungsdaten" type="cst:Zahlungsdaten_Type">
+				<xsd:annotation>
+					<xsd:documentation>Beschreibt die Art der Zahlung und enthält die zugehörigen Daten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Sepa" type="cst:SepaCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>SEPA-Mandat-Steuerung, wenn Zahlungsdaten ein SEPA-Mandat notwendig machen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Vinkulierung" type="cst:Vinkularglaeubiger_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Vinkulierungsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Polizzenversand" type="cst:PolizzenversandType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>alternativer Polizzenversand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Datenschutzbestimmungen" type="cst:Datenverwendung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Allgemeine Datenschutzbestimmungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Kontierung" type="cst:Kontierung_Type" minOccurs="0" maxOccurs="3"/>
+			<xsd:element name="Ersatzpolizzennummer" type="cst:Ersatzpolizzen_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ersatzpolizzennummern bei Konvertierung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusendungWeitereDokumente" type="xsd:string" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Sollen weitere Antragsdokumente zugestellt werden (z.B. IVK)</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdaten" type="ZusaetzlicheAntragsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!--Abstrakte BOA-Operationstypen-->
+	<xsd:complexType name="CalculateRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="RequestUpselling" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation>Sollen Upselling-Vorschläge mitberechnet werden? Wenn ja kann dies zu einer längeren Berechnungsdauer führen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Ergebnis der Berechnung enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für das Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Offert enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Offertdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für den Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der den Antrag enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>optional ein aktueller Status des Antragsprozess</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn der Antrag fehlerfrei erstellt werden konnte, die Referenz auf diesen Antrag. Diese Referenz ist bei der Einreichung des Antrags anzugegeben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Referenz auf einen zuvor mit CreateApplication erzeugten Antrag, welcher jetzt eingereicht werden soll. Diese Referenz wird durch CreateApplication erzeugt. Entweder ist solch ein Bezug zu einem vorangegangenen SubmitApplication mitzugeben oder nochmals die Daten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>aktueller Status des eingespielten Antrages</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheAntragsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung des Antrags um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokumentId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>Eine DokumentenId als String</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokument" type="cst:DokumentInfo_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetApplicationDocumentRequest" type="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetApplicationDocumentResponse" type="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_4_0/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,595 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.4.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>Produktmodell Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="VerkaufsproduktKfz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Verkaufsprodukt_Type">
+				<xsd:sequence>
+					<xsd:element name="Gebdat" type="xsd:date" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Geburtsdatum als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PLZ" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PLZ als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="7"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="PersArtCd" type="omds:PersArtCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PersonArtCd als Tarifmerkmal: N = nat. Person, S = sonst. Person</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="KfzVersicherung" type="ProduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="KfzZusatzVersicherung" type="ZusatzproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteFahrzeuge" type="cst:Fahrzeug_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>In Analogie zum OMDS-Datensatz befinden sich die Risikoobjekte als Element in der obersten Produktebene (OMDS Datensatz Element VERTRAG)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produkt, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element name="Haftpflicht" type="HaftpflichtKfz_Type"/>
+					<xsd:choice>
+						<xsd:element name="Teilkasko" type="TeilkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+						<xsd:element name="Vollkasko" type="VollkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:choice>
+					<xsd:element name="Insassenunfall" type="InsassenUnfallKfz_Type" minOccurs="0"/>
+					<xsd:element name="Assistance" type="AssistanceKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Zusatzprodukte, die mit einer KFZ-Versicherung gebündelt werden können.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+					<xsd:element name="LeasingVerbundUnternehmen" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="HaftpflichtKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Haftpflicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Haftpflicht erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element ref="omds:EL-Versicherungssumme">
+						<xsd:annotation>
+							<xsd:documentation>Versicherungssumme Haftpflicht</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VarianteLeihwagen" type="VarianteLeihwagen_Type"/>
+					<xsd:element ref="omds:EL-Einstufung"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="VDNummer" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="KaskoKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für die Kasko-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Teilkasko bzw. KFZ-Vollkasko erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SelbstbehaltBisBetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="KMLeistung" type="xsd:unsignedInt" minOccurs="0"/>
+					<xsd:element name="VorsteuerAbzugBerechtigung" type="xsd:boolean"/>
+					<xsd:element name="Vinkulierung" type="cst:Vinkulierung_Type" minOccurs="0"/>
+					<xsd:element name="Bezugsrecht" type="cst:Bezugsrecht_Type" minOccurs="0"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Eingeschraenkt" type="xsd:boolean" default="0" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TeilkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Teilkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Vandalismusklausel" type="xsd:boolean"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VollkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Vollkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Neuwertklausel" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Leasingklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="InsassenUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Insassenunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="InsassenUnfallSystem" type="InsassenUnfallSystem_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LenkerUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Lenkerunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AssistanceKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Assistance</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfzRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Kfz-Rechtsschutz-Versicherung, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkehrsrechtsschutz" type="VerkehrsrechtsschutzKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VerkehrsrechtsschutzKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Verkehrsrechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Typen für die BOA-Services fuer Kfz -->
+	<xsd:complexType name="SpezBerechnungKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antragsanfrage und Antragsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+					<xsd:element name="BonusMalus" type="cst:BonusMalusSystem_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>BonusMalus beim Verband</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheKfzDaten" type="ZusaetzlicheKfzdaten_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingKfzResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Alternativen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="UpsellingVerkaufsprodukte" type="VerkaufsproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Berechnung die Details der Berechnung.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ResponseUpselling" type="UpsellingKfzResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Request für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Response für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Erstellung eines Offerts.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="SpezOffertKfz_Type"/>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional die Daten des Antrags, wenn nicht Bezug auf ein vorangegangenes SubmitApplication genommen wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Hier werden nochmals alle Antragsdaten zur Verfügung gestellt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Konkrete Services (Request- und Responseobjekte) Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="CalculateKfzRequest" type="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Kfz Berechnung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateKfzResponse" type="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzRequest" type="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Kfz Offert</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzResponse" type="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offert Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzRequest" type="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für einen Kfz Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzResponse" type="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antrag Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzRequest" type="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzResponse" type="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="FahrzeugRefLfdNr" type="xsd:string">
+		<xsd:annotation>
+			<xsd:documentation>Refernziert auf ein versichertes Fahrzeug über die laufende Nummer innerhalb eines Elementarprodukts.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="VorversicherungenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Vorversicherungen für Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Vorversicherungen_Type">
+				<xsd:sequence>
+					<xsd:element name="VorversicherungKfz" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="cst:VorversicherungenDetail_Type">
+									<xsd:attribute name="VtgSparteCd" type="omds:VtgSparteCd_Type" use="optional"/>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="VorversicherungRechtsschutz" type="cst:VorversicherungenDetail_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="InsassenUnfallSystem_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type System Insassenunfallversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Pauschalsystem"/>
+			<xsd:enumeration value="Platzsystem1"/>
+			<xsd:enumeration value="Platzsystem2"/>
+			<xsd:enumeration value="Personensystem"/>
+			<xsd:enumeration value="Lenkerunfallversicherung"/>
+			<xsd:enumeration value="Aufsassenunfallversicherung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="VarianteLeihwagen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Variante Leihwagen (A, B)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="VA">
+				<xsd:annotation>
+					<xsd:documentation>ohne Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VB">
+				<xsd:annotation>
+					<xsd:documentation>mit Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Zusätzliche KFZ-Daten -->
+	<xsd:complexType name="ZusaetzlicheKfzdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zusätzliche Kfz-Daten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="KfzKennzeichen">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="3"/>
+						<xsd:maxLength value="9"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="Fahrgestellnummer" type="Fahrgestellnummer_Type"/>
+			<xsd:element name="ErfolgtAnmeldungZeitgleichMitAbmeldung" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="AbmeldedatumWechselkennzeichenFahrzeug" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="Wechselkennzeichen" type="Wechselkennzeichen_Type" minOccurs="0"/>
+			<xsd:element name="Fahrzeugzustand" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Fahrzeugzustand als Schlüsselwerte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="FzZustandBesichtigung" type="FzZustandBesichtigung_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Detailierte Fahrzeugzustandsbeschreibung z.B. aus einer Besichtigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdatenKfz" type="ZusaetzlicheAntragsdatenKfz_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Wechselkennzeichen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Wechselkennzeichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="WechselkennzeichenArt">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Neues Fahrzeug als WKZ in bestehenden Vertrag einbündeln"/>
+						<xsd:enumeration value="Fahrzeugwechsel im bestehenden WKZ-Vertrag"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="BestehenderWechselkennzeichenvertrag" type="xsd:string"/>
+			<xsd:element name="ErsetztWirdFahrgestellnummer" type="Fahrgestellnummer_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="Fahrgestellnummer_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Fahrgestellnummer FIN</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="30"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="FzZustandBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ergebnisse einer Besichtigung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ZustandsberichtLiegtAlsFormularBei" type="xsd:boolean" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zustandsbericht liegt als Formular bei bzw. Besichtigung durch externe Stelle veranlasst - muss dann als Attachment mitgeschickt werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArtBesichtigung" type="ArtBesichtigung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Die Art der Besichtigung bzw. Quelle der Zustandsbeschreibung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="SchaedenAnScheibenKleinglas" type="SchaedenAnScheibenKleinglas_Type" minOccurs="0"/>
+			<xsd:element name="SchaedenAmFahrzeug" type="SchaedenAmFahrzeug_Type" minOccurs="0"/>
+			<xsd:element name="KilometerLtBesichtigung" type="xsd:integer" minOccurs="0"/>
+			<xsd:element name="Vorschaeden" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsort" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsdatum" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="GrundFuerNachbesichtigung" type="xsd:string" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="ArtBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Zustandsbeschreibung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Besichtigung durch Betreuer"/>
+			<xsd:enumeration value="Kaufvertrag Markenhaendler mit Beschreibung"/>
+			<xsd:enumeration value="Besichtigung durch ARBOE, OEAMTC"/>
+			<xsd:enumeration value="Nachbesichtigung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAnScheibenKleinglas_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Beschreibung Schäden an Kleinglas</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an Scheiben / Kleinglas"/>
+			<xsd:enumeration value="Schäden an Scheiben / Kleinglas"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAmFahrzeug_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Schäden am Fahrzeug</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an der Karosserie"/>
+			<xsd:enumeration value="Schäden an der Karosserie"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ZusaetzlicheAntragsdatenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ für VU-Spezifische Erweiterungen bei der Kfz-Beschreibung im Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_5_0/omds3ServiceTypes.xsd

@@ -0,0 +1,681 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3ServiceTypes-1-1-0" xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:omds3ServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.5.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<!-- Beziehe Action Link -->
+	<xsd:element name="loginRequest" type="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt für den Actionlink</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ des Request-Objekts fuer den allgemeinen Portaleinstieg</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="loginResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Der Actionlink z.B. in das Maklerportal mit einem Token, der die Verbindung zur Session herstellt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<!-- Beziehe User-Daten -->
+	<xsd:element name="getUserDataRequest" type="UserDataRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt fuer den Zugriff auf die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die VUNr des angefragten Unternehmens. Dies ermöglicht ggf. mehrere VUs über eine technische Lösung zu servicieren. Verwendet den Typ VUNr aus OMDS-Datensatz.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getUserDataResponse" type="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Das Ergebnisobjekt fuer die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Type mit Benutzerinformationen. Das Element 'address' ist mit Version 1.1.0 entfallen, da diese Informationen auch im Element 'person' übermittelt werden können
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="userid">
+				<xsd:annotation>
+					<xsd:documentation>BenutzerId</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="availableServices">
+				<xsd:annotation>
+					<xsd:documentation>Liste der für diesen User unterstützen Services</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="service" type="xsd:string" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Die ServiceId des jeweiligen Webservice als String</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="person" type="omds:PERSON_Type">
+				<xsd:annotation>
+					<xsd:documentation>Ist vom Typ PERSON_Type aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste verfuegbarer OMDS-Datensaetze -->
+	<xsd:element name="getOMDSPackageListRequest" type="OMDSPackageListRequest">
+		<xsd:annotation>
+			<xsd:documentation>Inputobjekt zum Beziehen einer Liste verfuegbarer OMDS-Datensaetze</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>die VUNr aus OMDS als optionaler Filterparameter</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>von inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>bis inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageListResponse" type="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabeobjekt für eine Liste von OMDS-Datensätzen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine Liste von OMDS-Datensaetzen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence minOccurs="0">
+			<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" minOccurs="0" maxOccurs="unbounded"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe einzelnen OMDS-Datensatz -->
+	<xsd:element name="getOMDSPackageRequest" type="OMDSPackageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Requestobjekt fuer die Abholung eines oder mehrerer OMDS-Datensatz-Packages</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageId" type="xsd:string" nillable="false" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Datensatzes unter welcher er ueber Webservices referenziert werden kann. Es handelt sich nicht um eine Id aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageResponse" type="OMDSPackageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Gibt die Liste der angeforderten OMDS-Packages zurück oder entsprechende fachliche Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageResponse">
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackage" type="RequestedOMDSPackage" nillable="false" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste der angeforderten Pakete</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="RequestedOMDSPackage">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer ein OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackageId" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Die angefragte Id des OMDS-Datenpakets, wobei dies kein Schlüssel aus dem Paket ist. </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="omdsPackage" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Nur enthalten, wenn es das angeforderte Paket tatsächlich gibt und der User darauf berechtigt ist.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" nillable="false">
+							<xsd:annotation>
+								<xsd:documentation>Meta-Informationen zu diesem Paket</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="content" type="xsd:base64Binary" xmime:expectedContentTypes="application/zip">
+							<xsd:annotation>
+								<xsd:documentation>Gezippte OMDS-Daten als base64Binary oder mit Binary mit MTOM</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="OMDSPackageInfoType">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die wesentlichen Informationen zu einem OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="MaklerID" type="cst:MaklerID_Type" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Entspricht der MaklerID in OMDS 2.x. Die MaklerID (in Version 1.0.0 noch AgentID) ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für die jeweilige VU oder den jeweiligen Dienstleister, bei dem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die agentID mit der Vermittlernummer "Vermnr" (in Version 1.0.0 noch agentNumber) zusammenfällt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des OMDS Pakets und Angaben zu ihrer Verwendbarkeit, wobei hier kein Schlüssel aus einem OMDS Paket selbst gemeint ist, sondern eine eigenständige Id, die das Abrufen des OMDS-Pakets ermöglicht.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="timeStamp" type="omds:Datum-Zeit" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Zeitstempel der Erstellung entsprechend dem Attribut PaketZpktErstell mit OMDS Datum-Zeit als Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageSize" type="xsd:int" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Groesse der Datei in Byte, de facto beschränkt auf max. ca. 2 GB da vom Typ int</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageExtent" type="omds:PaketUmfCd_Type">
+				<xsd:annotation>
+					<xsd:documentation>entspricht dem der Paketumfang wie er in OMDS 2.x im Typ PaketUmfCd_Type definiert ist: D = Differenz, G = Gesamtbestand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageContentCode" type="omds:PaketInhCd_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste von OMDS 2.x Elementen des Typs PaketInhCd_Type, die den Inhalt des Datenpakets beschreiben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste vertragsbezogener Dokumente -->
+	<xsd:element name="getArcImageInfosRequest" type="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfrage Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfragetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>die Polizzennummer als OMDS Polizzennr-Typ.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyType" type="omds:VtgProdCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für Polizzen eines bestimmten Typs. Das Attribut ist vom Typ VtgProdCd_Type des OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyPartnerRole" type="PolicyPartnerRole" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für bestimmte Partner in einer bestimmten Rolle</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf bestimmte Dokumententypen. Es gibt 15 definierte vertragsbezogene Dokumententypen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageInfosResponse" type="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabe Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Informationen zu Dokumenten, wenn vorhanden</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageRequest" type="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requesttyp zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArcImageId">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Dokuments vom Typ String</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<!--<xsd:element name="policy" type="Policy"/>-->
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageResponse" type="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responsetyp zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ArcContent" type="ArcContent" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Das Dokument und seine Meta-Informationen, wenn ein Dokument vorhanden war</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="PolicyPartnerRole">
+		<xsd:annotation>
+			<xsd:documentation>Partnerrollen in einer Polizze: Versicherungsnehmer, Versicherte Person</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS-Personennr (String mit 1-26 Zeichen) </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="partnerRole" type="cst:PartnerRoleType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Partnerrollen im Vertrag als PartnerRoleType: String mit 2 Zeichen: VN, VP</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcImageInfo">
+		<xsd:annotation>
+			<xsd:documentation>Information zu einem einzelnen Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Dokuments und Details zur Verwendung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="name" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Der Name des Dokuments als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType">
+				<xsd:annotation>
+					<xsd:documentation>Der inhaltliche Typ des Dokuments, z.B. "Polizze" oder "Finanzamtsbestätigung" als Integer-Code</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentType" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mime-Type des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentLength" type="xsd:long" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Größe des Dokuments in Byte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="date" type="xsd:date">
+				<xsd:annotation>
+					<xsd:documentation>Erstellungsdatum des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="docReference" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Verweis auf weitere Dokumente, die inhaltlich zu diesem Dokument gehören, z.B. AVB zu einer Polizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcContent">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument und das Dokument base64encoded</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo">
+				<xsd:annotation>
+					<xsd:documentation>Meta-Informationen zum Dokument</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcImage" type="xsd:base64Binary" xmime:expectedContentTypes="application/octet-stream">
+				<xsd:annotation>
+					<xsd:documentation>Das eigentliche Dokument als base64-Binary</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe Deep-Links -->
+	<xsd:element name="getDeepLinkClaimRequest" type="DeepLinkClaimRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Schaden Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkClaimRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="claimNumber" type="omds:Schadennr">
+				<xsd:annotation>
+					<xsd:documentation>Schadennummer vom Typ OMDS Schadennr</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkClaimResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt Deep-Link Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPartnerRequest" type="DeepLinkPartnerRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPartnerRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS Personennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPartnerResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkOfferRequest" type="DeepLinkOfferRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot/ Antrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkOfferRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="offerNumber" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer der Berechnung, des Angebots oder des Antrags.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkOfferResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot / Antrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPolicyRequest" type="DeepLinkPolicyRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPolicyRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer des Vertrags als OMDS Polizzennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPolicyResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkBusinessObjectResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Deep-Link auf Geschäftsobjekte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="withoutFrame" type="xsd:boolean">
+		<xsd:annotation>
+			<xsd:documentation>Soll ein Frame angezeigt werden oder nicht</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="httpActionLink" type="HttpActionLinkType"/>
+	<xsd:complexType name="HttpActionLinkType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen Deep-Link</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="url">
+				<xsd:annotation>
+					<xsd:documentation>String mit max. 1024 Zeichen</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="type">
+				<xsd:annotation>
+					<xsd:documentation>Code für Art der URL, z.B. Verträge, Dokumente, Schäden, Schadenmeldung als int-Type.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:int">
+						<xsd:enumeration value="1">
+							<xsd:annotation>
+								<xsd:documentation>Einstiegsseite</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="2">
+							<xsd:annotation>
+								<xsd:documentation>Suche Partner</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="3">
+							<xsd:annotation>
+								<xsd:documentation>Suche Vertrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="4">
+							<xsd:annotation>
+								<xsd:documentation>Suche Schaden</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="5">
+							<xsd:annotation>
+								<xsd:documentation>Suche Angebot/Antrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="6">
+							<xsd:annotation>
+								<xsd:documentation>Schadenübersicht</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden, keine Doublette zu Nr 12, da hier Übersicht über einzelnen Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="7">
+							<xsd:annotation>
+								<xsd:documentation>Dokumente</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="8">
+							<xsd:annotation>
+								<xsd:documentation>Anfrage</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="9">
+							<xsd:annotation>
+								<xsd:documentation>Stammdaten</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="10">
+							<xsd:annotation>
+								<xsd:documentation>Bearbeiten</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="11">
+							<xsd:annotation>
+								<xsd:documentation>Verträge</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="12">
+							<xsd:annotation>
+								<xsd:documentation>Schäden</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, Keine Doublette zu Nr 6 da hier eine Liste von Schäden zu einem gegebenen Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="13">
+							<xsd:annotation>
+								<xsd:documentation>Angebote</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner, keine Doublette zu Nr 14 Angebots-/ Antragsübersicht, da hier nur Angebote des Partners -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="14">
+							<xsd:annotation>
+								<xsd:documentation>Angebots-/ Antragsübersicht</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, keine Doublette zu Nr 13, da hier Übersichtsseite über alle Angebote/ Anträge des Service-Konsumenten -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="15">
+							<xsd:annotation>
+								<xsd:documentation>Inkassostand</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="16">
+							<xsd:annotation>
+								<xsd:documentation>Angebot</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="17">
+							<xsd:annotation>
+								<xsd:documentation>Schadenmeldung</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="18">
+							<xsd:annotation>
+								<xsd:documentation>Mahnungen</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="validUntil" type="xsd:dateTime" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ablaufzeitpunkt der Action-Links. Wenn Actionslinks vorhanden sind, dieses Element jedoch nicht oder mit dem Wert "null", so sind die ActionLinks zeitlich unbeschränkt gültig. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="DeepLinkBusinessObjectResponse">
+		<xsd:sequence>
+			<xsd:element name="httpActionLink" type="HttpActionLinkType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Linkbeschreibung vom Typ LinkType</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_5_0/omds3Services.wsdl

@@ -0,0 +1,747 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Release 1.5.0 -->
+<definitions name="omds3Services-1-4-0" targetNamespace="urn:omds3Services-1-4-0"
+xmlns:os="urn:omds3Services-1-4-0"
+xmlns:ost="urn:omds3ServiceTypes-1-1-0"
+xmlns:cst="urn:omds3CommonServiceTypes-1-1-0"
+xmlns:b="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen"
+xmlns:boak="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz"
+xmlns:boaSp="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat"
+xmlns:sch="urn:at.vvo.omds.types.omds3types.v1-4-0.on7schaden"
+xmlns="http://schemas.xmlsoap.org/wsdl/"
+xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
+xmlns:ns="http://www.w3.org/2001/XMLSchema"
+xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/"
+xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" schemaLocation="omds3_ON1_Basisfunktionen.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" schemaLocation="omds3_ON2_Antrag_Kfz.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" schemaLocation="omds3_ON2_Antrag_SachPrivat.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on7schaden" schemaLocation="omds3_ON7_Schaden.xsd"/>
+		</schema>
+	</types>
+	<message name="loginRequest">
+		<part name="parameters" element="ost:loginRequest"/>
+	</message>
+	<message name="loginResponse">
+		<part name="parameters" element="ost:loginResponse"/>
+	</message>
+
+	<message name="getUserDataRequest">
+		<part name="parameters" element="ost:getUserDataRequest"/>
+	</message>
+	<message name="getUserDataResponse">
+		<part name="parameters" element="ost:getUserDataResponse"/>
+	</message>
+
+	<message name="getOMDSPackageListRequest">
+		<part name="parameters" element="ost:getOMDSPackageListRequest"/>
+	</message>
+	<message name="getOMDSPackageListResponse">
+		<part name="parameters" element="ost:getOMDSPackageListResponse" />
+	</message>
+
+	<message name="getOMDSPackageRequest">
+		<part name="parameters" element="ost:getOMDSPackageRequest"/>
+	</message>
+	<message name="getOMDSPackageResponse">
+		<part name="parameters" element="ost:getOMDSPackageResponse" />
+	</message>
+
+	<!-- Vertragsbezogene Dokumente -->
+
+	<message name="getArcImageInfosRequest">
+		<part name="parameters" element="ost:getArcImageInfosRequest"/>
+	</message>
+	<message name="getArcImageInfosResponse">
+		<part name="parameters" element="ost:getArcImageInfosResponse" />
+	</message>
+	<message name="getArcImageRequest">
+		<part name="parameters" element="ost:getArcImageRequest"/>
+	</message>
+	<message name="getArcImageResponse">
+		<part name="parameters" element="ost:getArcImageResponse" />
+	</message>
+
+	<!-- Dokumente allgemein -->
+	<message name="AddDocToBusinessCaseRequestMsg">
+		<part name="parameters" element="b:AddDocToBusinessCaseRequest"/>
+	</message>
+	<message name="AddDocToBusinessCaseResponseMsg">
+		<part name="parameters" element="b:AddDocToBusinessCaseResponse" />
+	</message>
+	<message name="GetNumberOfDocumentsRequestMsg">
+		<part name="parameters" element="b:GetNumberOfDocumentsRequest"/>
+	</message>
+	<message name="GetNumberOfDocumentsResponseMsg">
+		<part name="parameters" element="b:GetNumberOfDocumentsResponse" />
+	</message>
+	<message name="GetDocumentsOfObjectRequestMsg">
+		<part name="parameters" element="b:GetDocumentsOfObjectRequest"/>
+	</message>
+	<message name="GetDocumentsOfObjectResponseMsg">
+		<part name="parameters" element="b:GetDocumentsOfObjectResponse" />
+	</message>
+	<message name="GetDocumentsOfPeriodRequestMsg">
+		<part name="parameters" element="b:GetDocumentsOfPeriodRequest"/>
+	</message>
+	<message name="GetDocumentsOfPeriodResponseMsg">
+		<part name="parameters" element="b:GetDocumentsOfPeriodResponse" />
+	</message>
+
+	<!-- Deep Links -->
+
+	<message name="deepLinkClaimRequest">
+		<part name="parameters" element="ost:getDeepLinkClaimRequest"/>
+	</message>
+	<message name="deepLinkClaimResponse">
+		<part name="parameters" element="ost:getDeepLinkClaimResponse" />
+	</message>
+
+	<message name="deepLinkPartnerRequest">
+		<part name="parameters" element="ost:getDeepLinkPartnerRequest"/>
+	</message>
+	<message name="deepLinkPartnerResponse">
+		<part name="parameters" element="ost:getDeepLinkPartnerResponse" />
+	</message>
+	<message name="deepLinkOfferRequest">
+		<part name="parameters" element="ost:getDeepLinkOfferRequest"/>
+	</message>
+	<message name="deepLinkOfferResponse">
+		<part name="parameters" element="ost:getDeepLinkOfferResponse" />
+	</message>
+	<message name="deepLinkPolicyRequest">
+		<part name="parameters" element="ost:getDeepLinkPolicyRequest"/>
+	</message>
+	<message name="deepLinkPolicyResponse">
+		<part name="parameters" element="ost:getDeepLinkPolicyResponse" />
+	</message>
+
+	<!-- Schaden -->
+	<message name="CheckClaimRequestMsg">
+		<part name="parameters" element="sch:CheckClaimRequest"/>
+	</message>
+	<message name="CheckClaimResponseMsg">
+		<part name="parameters" element="sch:CheckClaimResponse" />
+	</message>
+	<message name="SubmitClaimRequestMsg">
+		<part name="parameters" element="sch:SubmitClaimRequest"/>
+	</message>
+	<message name="SubmitClaimResponseMsg">
+		<part name="parameters" element="sch:SubmitClaimResponse" />
+	</message>
+	<message name="GetClaimRequestMsg">
+		<part name="parameters" element="sch:GetClaimRequest"/>
+	</message>
+	<message name="GetClaimResponseMsg">
+		<part name="parameters" element="sch:GetClaimResponse" />
+	</message>
+	<message name="SearchClaimRequestMsg">
+		<part name="parameters" element="sch:SearchClaimRequest"/>
+	</message>
+	<message name="SearchClaimResponseMsg">
+		<part name="parameters" element="sch:SearchClaimResponse" />
+	</message>
+
+	<!-- Kraftfahrt -->
+	<message name="CalculateKfzRequestMsg">
+		<part name="parameters" element="boak:CalculateKfzRequest"/>
+	</message>
+	<message name="CalculateKfzResponseMsg">
+		<part name="parameters" element="boak:CalculateKfzResponse"/>
+	</message>
+	<message name="CreateOfferKfzRequestMsg">
+		<part name="parameters" element="boak:CreateOfferKfzRequest"/>
+	</message>
+	<message name="CreateOfferKfzResponseMsg">
+		<part name="parameters" element="boak:CreateOfferKfzResponse"/>
+	</message>
+	<message name="CreateApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzRequest"/>
+	</message>
+	<message name="CreateApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzResponse"/>
+	</message>
+	<message name="SubmitApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzRequest"/>
+	</message>
+	<message name="SubmitApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzResponse"/>
+	</message>
+
+	<!-- SachPrivat -->
+	<message name="CalculateSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:CalculateSachPrivatRequest"/>
+	</message>
+	<message name="CalculateSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:CalculateSachPrivatResponse"/>
+	</message>
+	<message name="CreateOfferSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:CreateOfferSachPrivatRequest"/>
+	</message>
+	<message name="CreateOfferSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:CreateOfferSachPrivatResponse"/>
+	</message>
+	<message name="CreateApplicationSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:CreateApplicationSachPrivatRequest"/>
+	</message>
+	<message name="CreateApplicationSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:CreateApplicationSachPrivatResponse"/>
+	</message>
+	<message name="SubmitApplicationSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:SubmitApplicationSachPrivatRequest"/>
+	</message>
+	<message name="SubmitApplicationSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:SubmitApplicationSachPrivatResponse"/>
+	</message>
+
+	<!-- Fehler -->
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+
+
+	<portType name="omdsServicePortType">
+
+		<operation name="login">
+			<input name="loginRequest" message="os:loginRequest" />
+			<output name="loginResponse" message="os:loginResponse" />
+            <fault name="loginFault" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="getUserData">
+			<input name="getUserDataRequest" message="os:getUserDataRequest" />
+			<output name="getUserDataResponse" message="os:getUserDataResponse" />
+			<fault name="getUserDataFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<input name="getOMDSPackageListRequest" message="os:getOMDSPackageListRequest" />
+			<output name="getOMDSPackageListResponse" message="os:getOMDSPackageListResponse" />
+			<fault name="getOMDSPackageListFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<input name="getOMDSPackageRequest" message="os:getOMDSPackageRequest" />
+			<output name="getOMDSPackageResponse" message="os:getOMDSPackageResponse" />
+			<fault name="getOMDSPackageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImageInfos">
+			<input name="getArcImageInfosRequest" message="os:getArcImageInfosRequest" />
+			<output name="getArcImageInfosResponse" message="os:getArcImageInfosResponse" />
+			<fault name="getArcImageInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImage">
+			<input name="getArcImageRequest" message="os:getArcImageRequest" />
+			<output name="getArcImageResponse" message="os:getArcImageResponse" />
+			<fault name="getArcImageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkClaim">
+			<input name="deepLinkClaimRequest" message="os:deepLinkClaimRequest" />
+			<output name="deepLinkClaimResponse" message="os:deepLinkClaimResponse" />
+			<fault name="deepLinkClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<input name="deepLinkPartnerRequest" message="os:deepLinkPartnerRequest" />
+			<output name="deepLinkPartnerResponse" message="os:deepLinkPartnerResponse" />
+			<fault name="deepLinkPartnerFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<input name="deepLinkOfferRequest" message="os:deepLinkOfferRequest" />
+			<output name="deepLinkOfferResponse" message="os:deepLinkOfferResponse" />
+			<fault name="deepLinkOfferFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<input name="deepLinkPolicyRequest" message="os:deepLinkPolicyRequest" />
+			<output name="deepLinkPolicyResponse" message="os:deepLinkPolicyResponse" />
+			<fault name="deepLinkPolicyFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+
+		<operation name="addDocToBusinessCase">
+			<input name="AddDocToBusinessCaseRequestPort" message="os:AddDocToBusinessCaseRequestMsg" />
+			<output name="AddDocToBusinessCaseResponsePort" message="os:AddDocToBusinessCaseResponseMsg" />
+			<fault name="AddDocToBusinessCaseFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getNumberOfDocuments">
+			<input name="GetNumberOfDocumentsRequestPort" message="os:GetNumberOfDocumentsRequestMsg" />
+			<output name="GetNumberOfDocumentsResponsePort" message="os:GetNumberOfDocumentsResponseMsg" />
+			<fault name="GetNumberOfDocumentsFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentsOfObject">
+			<input name="GetDocumentsOfObjectRequestPort" message="os:GetDocumentsOfObjectRequestMsg" />
+			<output name="GetDocumentsOfObjectResponsePort" message="os:GetDocumentsOfObjectResponseMsg" />
+			<fault name="GetDocumentsOfObjectFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentsOfPeriod">
+			<input name="GetDocumentsOfPeriodRequestPort" message="os:GetDocumentsOfPeriodRequestMsg" />
+			<output name="GetDocumentsOfPeriodResponsePort" message="os:GetDocumentsOfPeriodResponseMsg" />
+			<fault name="GetDocumentsOfPeriodFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="checkClaim">
+			<input name="CheckClaimRequestPort" message="os:CheckClaimRequestMsg" />
+			<output name="CheckClaimResponsePort" message="os:CheckClaimResponseMsg" />
+			<fault name="CheckClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="submitClaim">
+			<input name="SubmitClaimRequestPort" message="os:SubmitClaimRequestMsg" />
+			<output name="SubmitClaimResponsePort" message="os:SubmitClaimResponseMsg" />
+			<fault name="SubmitClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaim">
+			<input name="GetClaimRequestPort" message="os:GetClaimRequestMsg" />
+			<output name="GetClaimResponsePort" message="os:GetClaimResponseMsg" />
+			<fault name="GetClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="searchClaim">
+			<input name="SearchClaimRequestPort" message="os:SearchClaimRequestMsg" />
+			<output name="SearchClaimResponsePort" message="os:SearchClaimResponseMsg" />
+			<fault name="SearchClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="calculateKfz">
+			<input name="CalculateKfzRequestPort" message="os:CalculateKfzRequestMsg"/>
+			<output name="CalculateKfzResponsePort" message="os:CalculateKfzResponseMsg"/>
+			<fault name="CalculateKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createOfferKfz">
+			<input name="CreateOfferKfzRequestPort" message="os:CreateOfferKfzRequestMsg"/>
+			<output name="CreateOfferKfzResponsePort" message="os:CreateOfferKfzResponseMsg"/>
+			<fault name="CreateOfferKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createApplicationKfz">
+			<input name="CreateApplicationKfzRequestPort" message="os:CreateApplicationKfzRequestMsg"/>
+			<output name="CreateApplicationKfzResponsePort" message="os:CreateApplicationKfzResponseMsg"/>
+			<fault name="CreateApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<input name="SubmitApplicationKfzRequestPort" message="os:SubmitApplicationKfzRequestMsg"/>
+			<output name="SubmitApplicationKfzResponsePort" message="os:SubmitApplicationKfzResponseMsg"/>
+			<fault name="SubmitApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+
+		<operation name="calculateSachPrivat">
+			<input name="CalculateSachPrivatRequestPort" message="os:CalculateSachPrivatRequestMsg"/>
+			<output name="CalculateSachPrivatResponsePort" message="os:CalculateSachPrivatResponseMsg"/>
+			<fault name="CalculateSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createOfferSachPrivat">
+			<input name="CreateOfferSachPrivatRequestPort" message="os:CreateOfferSachPrivatRequestMsg"/>
+			<output name="CreateOfferSachPrivatResponsePort" message="os:CreateOfferSachPrivatResponseMsg"/>
+			<fault name="CreateOfferSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createApplicationSachPrivat">
+			<input name="CreateApplicationSachPrivatRequestPort" message="os:CreateApplicationSachPrivatRequestMsg"/>
+			<output name="CreateApplicationSachPrivatResponsePort" message="os:CreateApplicationSachPrivatResponseMsg"/>
+			<fault name="CreateApplicationSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="submitApplicationSachPrivat">
+			<input name="SubmitApplicationSachPrivatRequestPort" message="os:SubmitApplicationSachPrivatRequestMsg"/>
+			<output name="SubmitApplicationSachPrivatResponsePort" message="os:SubmitApplicationSachPrivatResponseMsg"/>
+			<fault name="SubmitApplicationSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+
+
+		<operation name="login">
+			<soap:operation soapAction="urn:login" style="document" />
+			<input name="loginRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="loginResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="loginFault">
+				<soap:fault name="loginFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getUserData">
+			<soap:operation soapAction="urn:getUserData" style="document" />
+			<input name="getUserDataRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getUserDataResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getUserDataFault">
+				<soap:fault name="getUserDataFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<soap:operation soapAction="urn:getOMDSPackageList" style="document" />
+			<input name="getOMDSPackageListRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageListResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageListFault">
+				<soap:fault name="getOMDSPackageListFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<soap:operation soapAction="urn:getOMDSPackage" style="document" />
+			<input name="getOMDSPackageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageFault">
+				<soap:fault name="getOMDSPackageFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Vertragsbezogene Dokumente ArcImage -->
+
+		<operation name="getArcImageInfos">
+			<soap:operation soapAction="urn:getArcImageInfos" style="document" />
+			<input name="getArcImageInfosRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageInfosResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageInfosFault">
+				<soap:fault name="getArcImageInfosFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getArcImage">
+			<soap:operation soapAction="urn:getArcImage" style="document" />
+			<input name="getArcImageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageFault">
+				<soap:fault name="getArcImageFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Deep-Links -->
+
+		<operation name="deepLinkClaim">
+			<soap:operation soapAction="urn:deepLinkClaim" style="document" />
+			<input name="deepLinkClaimRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkClaimResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkClaimFault">
+				<soap:fault name="deepLinkClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<soap:operation soapAction="urn:deepLinkPartner" style="document" />
+			<input name="deepLinkPartnerRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPartnerResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPartnerFault">
+				<soap:fault name="deepLinkPartnerFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<soap:operation soapAction="urn:deepLinkOffer" style="document" />
+			<input name="deepLinkOfferRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkOfferResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkOfferFault">
+				<soap:fault name="deepLinkOfferFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<soap:operation soapAction="urn:deepLinkPolicy" style="document" />
+			<input name="deepLinkPolicyRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPolicyResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPolicyFault">
+				<soap:fault name="deepLinkPolicyFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Dokumentenhandling -->
+
+		<operation name="addDocToBusinessCase">
+			<soap:operation soapAction="urn:addDocToBusinessCase" style="document" />
+			<input name="AddDocToBusinessCaseRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="AddDocToBusinessCaseResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="AddDocToBusinessCaseFault">
+				<soap:fault name="AddDocToBusinessCaseFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getNumberOfDocuments">
+			<soap:operation soapAction="urn:getNumberOfDocuments" style="document" />
+			<input name="GetNumberOfDocumentsRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetNumberOfDocumentsResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetNumberOfDocumentsFault">
+				<soap:fault name="GetNumberOfDocumentsFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getDocumentsOfObject">
+			<soap:operation soapAction="urn:getDocumentsOfObject" style="document" />
+			<input name="GetDocumentsOfObjectRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentsOfObjectResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentsOfObjectFault">
+				<soap:fault name="GetDocumentsOfObjectFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getDocumentsOfPeriod">
+			<soap:operation soapAction="urn:getDocumentsOfPeriod" style="document" />
+			<input name="GetDocumentsOfPeriodRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentsOfPeriodResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentsOfPeriodFault">
+				<soap:fault name="GetDocumentsOfPeriodFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Schaden -->
+		<operation name="checkClaim">
+			<soap:operation soapAction="urn:checkClaim" style="document" />
+			<input name="CheckClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="CheckClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="CheckClaimFault">
+				<soap:fault name="CheckClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="submitClaim">
+			<soap:operation soapAction="urn:submitClaim" style="document" />
+			<input name="SubmitClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SubmitClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SubmitClaimFault">
+				<soap:fault name="SubmitClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getClaim">
+			<soap:operation soapAction="urn:getClaim" style="document" />
+			<input name="GetClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimFault">
+				<soap:fault name="GetClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="searchClaim">
+			<soap:operation soapAction="urn:searchClaim" style="document" />
+			<input name="SearchClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SearchClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SearchClaimFault">
+				<soap:fault name="SearchClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- KFZ -->
+		<operation name="calculateKfz">
+			<soap:operation soapAction="urn:calculateKfz" style="document"/>
+			<input name="CalculateKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CalculateKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CalculateKfzFault">
+				<soap:fault name="CalculateKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createOfferKfz">
+			<soap:operation soapAction="urn:createOfferKfz" style="document"/>
+			<input name="CreateOfferKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateOfferKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateOfferKfzFault">
+				<soap:fault name="CreateOfferKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createApplicationKfz">
+			<soap:operation soapAction="urn:createApplicationKfz" style="document"/>
+			<input name="CreateApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateApplicationKfzFault">
+				<soap:fault name="CreateApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<soap:operation soapAction="urn:submitApplicationKfz" style="document"/>
+			<input name="SubmitApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="SubmitApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="SubmitApplicationKfzFault">
+				<soap:fault name="SubmitApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- SachPrivat -->
+		<operation name="calculateSachPrivat">
+			<soap:operation soapAction="urn:calculateSachPrivat" style="document"/>
+			<input name="CalculateSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CalculateSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CalculateSachPrivatFault">
+				<soap:fault name="CalculateSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createOfferSachPrivat">
+			<soap:operation soapAction="urn:createOfferSachPrivat" style="document"/>
+			<input name="CreateOfferSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateOfferSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateOfferSachPrivatFault">
+				<soap:fault name="CreateOfferSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createApplicationSachPrivat">
+			<soap:operation soapAction="urn:createApplicationSachPrivat" style="document"/>
+			<input name="CreateApplicationSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateApplicationSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateApplicationSachPrivatFault">
+				<soap:fault name="CreateApplicationSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="submitApplicationSachPrivat">
+			<soap:operation soapAction="urn:submitApplicationSachPrivat" style="document"/>
+			<input name="SubmitApplicationSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="SubmitApplicationSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="SubmitApplicationSachPrivatFault">
+				<soap:fault name="SubmitApplicationSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+
+	</binding>
+
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+
+
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy"
+	    xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	    xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<!-- Def HTTPS: Erzwingt Ende-zu-Ende Verschluesselung -->
+				<!-- Dies muss allerdings nur aktiviert werden, wenn nicht andere Infrastruktur eine sichere Https-Verbindung gewaehrleistet -->
+				<sp:TransportBinding>
+					<wsp:Policy>
+						<sp:TransportToken>
+							<wsp:Policy>
+								<sp:HttpsToken RequireClientCertificate="false"/>
+							</wsp:Policy>
+						</sp:TransportToken>
+					</wsp:Policy>
+				</sp:TransportBinding>
+
+				<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+				<sp:SupportingTokens>
+					<wsp:Policy>
+						<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+							<wsp:Policy>
+								<sp:HashPassword/>
+							</wsp:Policy>
+						</sp:UsernameToken>
+					</wsp:Policy>
+				</sp:SupportingTokens>
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+
+</definitions>

client-lib/src/main/resources/def/r1_5_0/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.5.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:element name="AddDocToBusinessCaseRequest" type="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts, um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type"/>
+			<xsd:element name="Dokument" type="cst:Upload_Dokument_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="AddDocToBusinessCaseResponse" type="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice maxOccurs="unbounded">
+			<xsd:element name="DocRef" type="cst:DokumentenReferenz_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsRequest" type="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Anzahl von Dokumenten zu einem fachlichen Objekt zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ enthält die Elemente fuer die Anfrage nach Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type">
+				<xsd:annotation>
+					<xsd:documentation>ObjektSpezifikation kann ab Version 1.3 entfallen, es kann aber sein, dass das Versicherungsunternehmen einen Fehler meldet, weil es Anfragen nur mit Objektspezifikation unterstützt oder weil die Ergebnismenge zu groß wäre.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsResponse" type="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response mit einer Anzahl von Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="AnzDokumente" type="xsd:nonNegativeInteger"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectRequest" type="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines fachlichen Objekts zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectResponse" type="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodRequest" type="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines Zeitraums zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type" minOccurs="0"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodResponse" type="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:complexType name="DocumentInfosResponseResult_Type">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ActualOffset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Der tatsächliche Offset in der  Ergebnisliste.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ActualMaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Tatsächliche Maximalanzahl der Ergebnisse, die der Provider auf eine Anfrage zurück gibt. Beispiel: Consumer fordert 1000 Ergebnisse an, Provider liefert aber maximal 100 zurück. In diesem Fall würde hier 100 zurückgegeben. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="TotalResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Gesamtzahl der Dokumente unter dem gewählten Filter.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="DokumentInfos" type="cst:DokumentenReferenz_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_5_0/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,393 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ost="urn:omds3ServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.5.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<!--Prozessobjekte Berechnung, Offert, Antrag - Spartenübergreifend-->
+	<xsd:complexType name="SpezBerechnung_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Berechnung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffert_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Offert, der bei Request und Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Offertnummer" type="cst:ObjektId_Type" minOccurs="0"/>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntrag_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Antragsart" type="cst:Antragsart_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die Antragsart kann auch vom ServiceProvider automatisch bestimmt werden, dann bleibt sie im Request leer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Vertragspersonen (nicht versicherte Personen), welche dann über ihre Rolle referenziert werden. Die Personen können eine Adresse enthalten.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbweichenderPraemienzahler" type="xsd:unsignedShort" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf einen abweichenden Praemienzahler, wenn nicht der Verisicherungsnehmer die Prämie zahlt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVersicherungsnehmer" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf weitere Versicherungsnehmer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVertragspersonen" type="cst:Vertragsperson_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Weitere Personen in Vertragsrollen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbgelehnteRisiken" type="cst:AbgelehnteRisiken_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Bestehen Ablehnungen zu den beantragten Risiken</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Vorversicherungen" type="cst:Vorversicherungen_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Bestehen Vorversicherungen zu dem Antrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zahlungsdaten" type="cst:Zahlungsdaten_Type">
+				<xsd:annotation>
+					<xsd:documentation>Beschreibt die Art der Zahlung und enthält die zugehörigen Daten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Sepa" type="cst:SepaCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>SEPA-Mandat-Steuerung, wenn Zahlungsdaten ein SEPA-Mandat notwendig machen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Polizzenversand" type="cst:PolizzenversandType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>alternativer Polizzenversand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Datenschutzbestimmungen" type="cst:Datenverwendung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Allgemeine Datenschutzbestimmungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Kontierung" type="cst:Kontierung_Type" minOccurs="0" maxOccurs="3"/>
+			<xsd:element name="Ersatzpolizzennummer" type="cst:Ersatzpolizzen_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ersatzpolizzennummern bei Konvertierung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusendungWeitereDokumente" type="xsd:string" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Sollen weitere Antragsdokumente zugestellt werden (z.B. IVK)</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdaten" type="ZusaetzlicheAntragsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!--Abstrakte BOA-Operationstypen-->
+	<xsd:complexType name="CalculateRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="RequestUpselling" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation>Sollen Upselling-Vorschläge mitberechnet werden? Wenn ja kann dies zu einer längeren Berechnungsdauer führen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Ergebnis der Berechnung enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für das Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Offert enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Offertdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für den Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der den Antrag enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>optional ein aktueller Status des Antragsprozess</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn der Antrag fehlerfrei erstellt werden konnte, die Referenz auf diesen Antrag. Diese Referenz ist bei der Einreichung des Antrags anzugegeben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Referenz auf einen zuvor mit CreateApplication erzeugten Antrag, welcher jetzt eingereicht werden soll. Diese Referenz wird durch CreateApplication erzeugt. Entweder ist solch ein Bezug zu einem vorangegangenen SubmitApplication mitzugeben oder nochmals die Daten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>aktueller Status des eingespielten Antrages</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response Berechnung </xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Offerterstellung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Offerterstellung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragserzeugung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragserzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragsüberleitung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheAntragsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung des Antrags um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokumentId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>Eine DokumentenId als String</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokument" type="cst:DokumentInfo_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetApplicationDocumentRequest" type="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetApplicationDocumentResponse" type="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_5_0/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,600 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.5.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>Produktmodell Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="VerkaufsproduktKfz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Verkaufsprodukt_Type">
+				<xsd:sequence>
+					<xsd:element name="Gebdat" type="xsd:date" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Geburtsdatum als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PLZ" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PLZ als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="7"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="PersArtCd" type="omds:PersArtCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PersonArtCd als Tarifmerkmal: N = nat. Person, S = sonst. Person</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="KfzVersicherung" type="ProduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="KfzZusatzVersicherung" type="ZusatzproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteFahrzeuge" type="cst:Fahrzeug_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>In Analogie zum OMDS-Datensatz befinden sich die Risikoobjekte als Element in der obersten Produktebene (OMDS Datensatz Element VERTRAG)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produkt, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element name="Haftpflicht" type="HaftpflichtKfz_Type"/>
+					<xsd:choice>
+						<xsd:element name="Teilkasko" type="TeilkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+						<xsd:element name="Vollkasko" type="VollkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:choice>
+					<xsd:element name="Insassenunfall" type="InsassenUnfallKfz_Type" minOccurs="0"/>
+					<xsd:element name="Assistance" type="AssistanceKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Zusatzprodukte, die mit einer KFZ-Versicherung gebündelt werden können.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+					<xsd:element name="LeasingVerbundUnternehmen" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="HaftpflichtKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Haftpflicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Haftpflicht erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element ref="omds:EL-Versicherungssumme">
+						<xsd:annotation>
+							<xsd:documentation>Versicherungssumme Haftpflicht</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VarianteLeihwagen" type="VarianteLeihwagen_Type"/>
+					<xsd:element ref="omds:EL-Einstufung"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="VDNummer" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="KaskoKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für die Kasko-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Teilkasko bzw. KFZ-Vollkasko erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SelbstbehaltBisBetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="KMLeistung" type="xsd:unsignedInt" minOccurs="0"/>
+					<xsd:element name="VorsteuerAbzugBerechtigung" type="xsd:boolean"/>
+					<xsd:element name="Vinkulierung" type="cst:Vinkulierung_Type" minOccurs="0"/>
+					<xsd:element name="Bezugsrecht" type="cst:Bezugsrecht_Type" minOccurs="0"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Eingeschraenkt" type="xsd:boolean" default="0" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TeilkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Teilkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Vandalismusklausel" type="xsd:boolean"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VollkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Vollkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Neuwertklausel" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Leasingklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="InsassenUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Insassenunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="InsassenUnfallSystem" type="InsassenUnfallSystem_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LenkerUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Lenkerunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AssistanceKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Assistance</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfzRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Kfz-Rechtsschutz-Versicherung, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkehrsrechtsschutz" type="VerkehrsrechtsschutzKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VerkehrsrechtsschutzKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Verkehrsrechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Typen für die BOA-Services fuer Kfz -->
+	<xsd:complexType name="SpezBerechnungKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antragsanfrage und Antragsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+					<xsd:element name="BonusMalus" type="cst:BonusMalusSystem_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>BonusMalus beim Verband</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vinkulierung" type="cst:Vinkularglaeubiger_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vinkulierungsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheKfzDaten" type="ZusaetzlicheKfzdaten_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingKfzResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Alternativen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="UpsellingVerkaufsprodukte" type="VerkaufsproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Berechnung die Details der Berechnung.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ResponseUpselling" type="UpsellingKfzResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Request für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Response für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Erstellung eines Offerts.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="SpezOffertKfz_Type"/>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional die Daten des Antrags, wenn nicht Bezug auf ein vorangegangenes SubmitApplication genommen wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Hier werden nochmals alle Antragsdaten zur Verfügung gestellt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Konkrete Services (Request- und Responseobjekte) Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="CalculateKfzRequest" type="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Kfz Berechnung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateKfzResponse" type="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzRequest" type="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Kfz Offert</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzResponse" type="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offert Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzRequest" type="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für einen Kfz Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzResponse" type="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antrag Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzRequest" type="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzResponse" type="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="FahrzeugRefLfdNr" type="xsd:string">
+		<xsd:annotation>
+			<xsd:documentation>Refernziert auf ein versichertes Fahrzeug über die laufende Nummer innerhalb eines Elementarprodukts.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="VorversicherungenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Vorversicherungen für Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Vorversicherungen_Type">
+				<xsd:sequence>
+					<xsd:element name="VorversicherungKfz" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="cst:VorversicherungenDetail_Type">
+									<xsd:attribute name="VtgSparteCd" type="omds:VtgSparteCd_Type" use="optional"/>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="VorversicherungRechtsschutz" type="cst:VorversicherungenDetail_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="InsassenUnfallSystem_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type System Insassenunfallversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Pauschalsystem"/>
+			<xsd:enumeration value="Platzsystem1"/>
+			<xsd:enumeration value="Platzsystem2"/>
+			<xsd:enumeration value="Personensystem"/>
+			<xsd:enumeration value="Lenkerunfallversicherung"/>
+			<xsd:enumeration value="Aufsassenunfallversicherung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="VarianteLeihwagen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Variante Leihwagen (A, B)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="VA">
+				<xsd:annotation>
+					<xsd:documentation>ohne Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VB">
+				<xsd:annotation>
+					<xsd:documentation>mit Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Zusätzliche KFZ-Daten -->
+	<xsd:complexType name="ZusaetzlicheKfzdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zusätzliche Kfz-Daten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="KfzKennzeichen">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="3"/>
+						<xsd:maxLength value="9"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="Fahrgestellnummer" type="Fahrgestellnummer_Type"/>
+			<xsd:element name="ErfolgtAnmeldungZeitgleichMitAbmeldung" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="AbmeldedatumWechselkennzeichenFahrzeug" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="Wechselkennzeichen" type="Wechselkennzeichen_Type" minOccurs="0"/>
+			<xsd:element name="Fahrzeugzustand" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Fahrzeugzustand als Schlüsselwerte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="FzZustandBesichtigung" type="FzZustandBesichtigung_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Detailierte Fahrzeugzustandsbeschreibung z.B. aus einer Besichtigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdatenKfz" type="ZusaetzlicheAntragsdatenKfz_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Wechselkennzeichen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Wechselkennzeichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="WechselkennzeichenArt">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Neues Fahrzeug als WKZ in bestehenden Vertrag einbündeln"/>
+						<xsd:enumeration value="Fahrzeugwechsel im bestehenden WKZ-Vertrag"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="BestehenderWechselkennzeichenvertrag" type="xsd:string"/>
+			<xsd:element name="ErsetztWirdFahrgestellnummer" type="Fahrgestellnummer_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="Fahrgestellnummer_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Fahrgestellnummer FIN</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="30"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="FzZustandBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ergebnisse einer Besichtigung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ZustandsberichtLiegtAlsFormularBei" type="xsd:boolean" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zustandsbericht liegt als Formular bei bzw. Besichtigung durch externe Stelle veranlasst - muss dann als Attachment mitgeschickt werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArtBesichtigung" type="ArtBesichtigung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Die Art der Besichtigung bzw. Quelle der Zustandsbeschreibung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="SchaedenAnScheibenKleinglas" type="SchaedenAnScheibenKleinglas_Type" minOccurs="0"/>
+			<xsd:element name="SchaedenAmFahrzeug" type="SchaedenAmFahrzeug_Type" minOccurs="0"/>
+			<xsd:element name="KilometerLtBesichtigung" type="xsd:integer" minOccurs="0"/>
+			<xsd:element name="Vorschaeden" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsort" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsdatum" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="GrundFuerNachbesichtigung" type="xsd:string" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="ArtBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Zustandsbeschreibung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Besichtigung durch Betreuer"/>
+			<xsd:enumeration value="Kaufvertrag Markenhaendler mit Beschreibung"/>
+			<xsd:enumeration value="Besichtigung durch ARBOE, OEAMTC"/>
+			<xsd:enumeration value="Nachbesichtigung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAnScheibenKleinglas_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Beschreibung Schäden an Kleinglas</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an Scheiben / Kleinglas"/>
+			<xsd:enumeration value="Schäden an Scheiben / Kleinglas"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAmFahrzeug_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Schäden am Fahrzeug</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an der Karosserie"/>
+			<xsd:enumeration value="Schäden an der Karosserie"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ZusaetzlicheAntragsdatenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ für VU-Spezifische Erweiterungen bei der Kfz-Beschreibung im Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_5_0/omds3_ON2_Antrag_SachPrivat.xsd

@@ -0,0 +1,677 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.5.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:complexType name="VersichertesObjektSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type für ein versichertes Objekt in der Sach-Privat-Versicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="ObjektId" type="cst:ObjektId_Type" minOccurs="0"/>
+					<xsd:element name="RisikoAdresse" type="RisikoAdresse_Type"/>
+					<xsd:element name="RisikoGebaeude" type="RisikoGebaeude_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="RisikoHaushalt" type="RisikoHaushalt_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoAdresse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Beschreibung einer Risikoadresse</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="omds:ADRESSE_Type">
+				<xsd:sequence>
+					<xsd:element name="Horazone" type="xsd:unsignedByte" minOccurs="0"/>
+					<xsd:element name="ImVerbautenOrt" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="AusserhalbDesOrtsgebiets" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="ErreichbarkeitFuerLoeschfahrzeuge" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Tarifzone" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoHaushalt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Risikobeschreibung Haushalt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="Wohnflaeche" type="xsd:unsignedShort">
+						<xsd:annotation>
+							<xsd:documentation>Wohnfläche in qm</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AusstattungCd" type="omds:AusstattungCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>zweckmäßig, standard, gehoben...</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="NutzungCd" type="omds:NutzungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>ständig bewohnt, nicht-ständig bewohnt, unbewohnt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheHaushaltDaten" type="ZusaetzlicheHaushaltsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Erweiterungsmöglichkeit für weitere benötigte Daten, die nicht im Standard enthalten sind.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="RisikoGebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zur Risikobeschreibung Gebäude</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VersichertesInteresseMitAttributMetadaten_Type">
+				<xsd:sequence>
+					<xsd:element name="GebaeudeArtCd" type="omds:GebaeudeArtCd_Type"/>
+					<xsd:element name="GebaeudeBez" type="xsd:string"/>
+					<xsd:element name="NutzungCd" type="omds:NutzungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>ständig bewohnt, nicht-ständig bewohnt, unbewohnt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BauartCd" type="omds:BauartCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Fertigteil, massiv, Holz...</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="DachungCd" type="omds:DachungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>hart, nicht-hart</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GebaeudeHoeheCd" type="omds:GebaeudeHoeheCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Ebenerdig, 1 Stockwerk, 2 Stockwerke oder mehr als 2 Stockwerke</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BaujahrGebaeude" type="xsd:integer">
+						<xsd:annotation>
+							<xsd:documentation>Jahreszahl</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="EL-Flaeche" type="omds:EL-Flaeche_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<!-- EL-Flaeche aus OMDS 2.10 -->
+					<xsd:element name="Vorschaeden" type="RisikoVorschaeden_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>wenn Vorschäden vorhanden sind, Typ des Schadens definieren</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="AusstattungCd" type="omds:AusstattungCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>zweckmäßig, standard, gehoben... (bei Gebäude oder nur in Haushalt?)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SichergKz" type="omds:Entsch2_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eigentumsrechte einer Bank ja / nein</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PreisProQm" type="omds:decimal">
+						<xsd:annotation>
+							<xsd:documentation>Gebäude oder doch Ausstattung?</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheGebaeudedaten" type="ZusaetzlicheGebaeudedaten_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Erweiterungsmöglichkeit für weitere benötigte Daten, die nicht im Standard enthalten sind.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheHaushaltsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp zur Definition zusätzlicher Haushaltsdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp zur Definition zusätzlicher Gebäudedaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenWintergarten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Wintergarten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenSolarthermie_Type">
+		<xsd:annotation>
+			<xsd:documentation>Strandardbaustein Solarthermie</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenSchwimmbad_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Schwimmbad</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheGebaeudedatenPhotovoltaik_Type">
+		<xsd:annotation>
+			<xsd:documentation>Standardbaustein Photovoltaik als Erweiterung von ZusaetzlicheGebaeudeDaten_Type</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusaetzlicheGebaeudedaten_Type">
+				<xsd:sequence/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="RisikoVorschaeden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurden die Gebäude/der Wohnungsinhalt/Keller in den letzten 7 Jahren durch Hochwasser, Überschwemmung, Muren oder Lawinen beschädigt?</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Vorschaeden"/>
+			<xsd:enumeration value="ein Vorschaden"/>
+			<xsd:enumeration value="mehr als ein Vorschaden"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="Nebengebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für Nebengebäude</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Abstellgebaeude"/>
+			<xsd:enumeration value="Badehütte"/>
+			<xsd:enumeration value="Bootshaus"/>
+			<xsd:enumeration value="Carport"/>
+			<xsd:enumeration value="ehemaliges Wirtschaftsgebaeude"/>
+			<xsd:enumeration value="Garage"/>
+			<xsd:enumeration value="Gartenhaus (nicht für Wohnzwecke)"/>
+			<xsd:enumeration value="Holzhütte"/>
+			<xsd:enumeration value="Keller"/>
+			<xsd:enumeration value="Mobilheim (stationaer)"/>
+			<xsd:enumeration value="Nebengebaeude"/>
+			<xsd:enumeration value="Nebengebaeude mit Garage"/>
+			<xsd:enumeration value="Presshaus"/>
+			<xsd:enumeration value="Sauna"/>
+			<xsd:enumeration value="Scheune / Schuppen / Stadel"/>
+			<xsd:enumeration value="Werkstaette"/>
+			<xsd:enumeration value="Werkzeug- und Geraeteschuppen"/>
+			<xsd:enumeration value="Wintergarten, Veranda"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="VerkaufsproduktSachPrivat_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Besitz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Produkte" type="ProduktSachPrivat_Type" maxOccurs="unbounded"/>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteObjekte" type="cst:VersichertesInteresse_Type" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurzelelement für Sach-Privat-Produkte, auf welchem alle Sach-Privat Produkte aufbauen sollen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ProduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersObjekteRefLfnr" type="xsd:unsignedShort" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<!--					<xsd:element name="Elementarprodukte" type="ElementarproduktSachPrivat_Type" minOccurs="0" maxOccurs="unbounded"/>
+Jens Buehring entfernt 2.6.2020 weil die Untertypen spezifischere Listen haben (fuer Gebaeude und Haushalt) und wenn man selbst ein
+Unterobjekt definiert, sollte man seine eigene spezifische Loesung verwenden.
+-->
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="ProduktGebaeudeversicherung" type="ProduktGebaeudeversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischeres Element für Gebäudeversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="ProduktHaushaltsversicherung" type="ProduktHaushaltsversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischeres Element für Gebäudeinhaltversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ProduktGebaeudeversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für Gebaeudeversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ProduktSachPrivat_Type">
+				<xsd:sequence>
+					<xsd:element name="Deckungen" type="ElementarproduktGebaeude_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktHaushaltsversicherung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für Gebäudeinhaltversicherungs-Produkte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ProduktSachPrivat_Type">
+				<xsd:sequence>
+					<xsd:element name="Deckungen" type="ElementarproduktHaushalt_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Wurzelelement für Sach-Privat-Elementarprodukte, auf welchem alle Sach-Privat Elementarprodukte aufbauen sollen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersObjekteRefLfnr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Pauschalbetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Selbstbehalt" type="cst:Selbstbehalt_Type" minOccurs="0"/>
+					<xsd:element name="Unterversicherungsverzicht" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="ProzentVersicherungssumme" type="xsd:unsignedShort" minOccurs="0"/>
+					<xsd:element name="Nebenkosten" type="cst:KostenFixOderProzent_Type" minOccurs="0"/>
+					<xsd:element name="Vorsorge" type="cst:KostenFixOderProzent_Type" minOccurs="0"/>
+					<xsd:element name="Hoechsthaftungssumme" type="omds:decimal" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktGebaeude_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für ein Gebäude-Elementarprodukt für einen Ansatz, in dem mit Vererbung für die einzelnen Sparten gearbeitet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktSachPrivat_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktHaushalt_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spezifischerer Typ für ein Gebäudeinhalts-Elementarprodukt für einen Ansatz, in dem mit Vererbung für die einzelnen Sparten gearbeitet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktSachPrivat_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GenElementarproduktGebaeude_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Elementarprodukt Gebäudeversicherung für einen Ansatz, in dem nicht mit Vererbung gearbeitet wird.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktGebaeude_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="GebaeudeSpartenCd_Type" minOccurs="1"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GenElementarproduktHaushalt_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Elementarprodukt Gebäudeinhaltsversicherung für einen Ansatz, in dem nicht mit Vererbung gearbeitet wird.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktHaushalt_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="HaushaltSpartenCd_Type" minOccurs="1"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="GebaeudeSpartenCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Basiert auf den Werten des SpartenCd_Type, diese Liste ist nur eingeschränkt auf die möglichen Gebäude Sparten Werte dürfen nur nach Aufnahme in den Basis-Typ hinzugefügt werden.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="999">
+				<xsd:annotation>
+					<xsd:documentation>sonstige</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="AS">
+				<xsd:annotation>
+					<xsd:documentation>Assistance</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="BU">
+				<xsd:annotation>
+					<xsd:documentation>Betriebs-Unterbrechung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ED">
+				<xsd:annotation>
+					<xsd:documentation>Einbruchdiebstahl</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="FE">
+				<xsd:annotation>
+					<xsd:documentation>Feuer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="GB">
+				<xsd:annotation>
+					<xsd:documentation>Glasbruch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HP">
+				<xsd:annotation>
+					<xsd:documentation>Haftpflicht</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="LW">
+				<xsd:annotation>
+					<xsd:documentation>Leitungswasser</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="MG">
+				<xsd:annotation>
+					<xsd:documentation>Maschinen und Geräte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="SS">
+				<xsd:annotation>
+					<xsd:documentation>Sonstige SV</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ST">
+				<xsd:annotation>
+					<xsd:documentation>Sturm</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="TI">
+				<xsd:annotation>
+					<xsd:documentation>Tierversicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="HaushaltSpartenCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Basiert auf den Werten des SpartenCd_Type, diese Liste ist nur eingeschränkt auf die möglichen Haushalt Sparten Werte dürfen nur nach Aufnahme in den Basis-Typ hinzugefügt werden.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="999">
+				<xsd:annotation>
+					<xsd:documentation>sonstige</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="AS">
+				<xsd:annotation>
+					<xsd:documentation>Assistance</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="BU">
+				<xsd:annotation>
+					<xsd:documentation>Betriebs-Unterbrechung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ED">
+				<xsd:annotation>
+					<xsd:documentation>Einbruchdiebstahl</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="EK">
+				<xsd:annotation>
+					<xsd:documentation>Elektronik</xsd:documentation>
+				</xsd:annotation>
+				<!-- auf Anforderung Generali, keine OMDS 2 Sparte -->
+			</xsd:enumeration>
+			<xsd:enumeration value="FE">
+				<xsd:annotation>
+					<xsd:documentation>Feuer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="GB">
+				<xsd:annotation>
+					<xsd:documentation>Glasbruch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HH">
+				<xsd:annotation>
+					<xsd:documentation>Haushalt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="HP">
+				<xsd:annotation>
+					<xsd:documentation>Haftpflicht</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="LW">
+				<xsd:annotation>
+					<xsd:documentation>Leitungswasser</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="MG">
+				<xsd:annotation>
+					<xsd:documentation>Maschinen und Geräte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="SS">
+				<xsd:annotation>
+					<xsd:documentation>Sonstige SV</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="ST">
+				<xsd:annotation>
+					<xsd:documentation>Sturm</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="TI">
+				<xsd:annotation>
+					<xsd:documentation>Tierversicherung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!--Typen für die BOA-Services fuer Besitz -->
+	<xsd:complexType name="BerechnungSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="OffertSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AntragSachPrivat_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antraganfrage und Antragantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="BerechnungSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="BerechnungSachPrivat_Type"/>
+					<xsd:element name="ResponseUpselling" type="UpsellingSachPrivatResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für ein Offert Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="OffertSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für ein Offert Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" type="OffertSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationSachPrivatRequest_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für einen Antrag Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für einen Antrag Besitz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsanfrage" type="AntragSachPrivat_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type des Response, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragsantwort" type="AntragSachPrivat_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CalculateSachPrivatRequest" type="CalculateSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateSachPrivatResponse" type="CalculateSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferSachPrivatRequest" type="CreateOfferSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Offerterzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferSachPrivatResponse" type="CreateOfferSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offerterzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationSachPrivatRequest" type="CreateApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Antragserzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationSachPrivatResponse" type="CreateApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antragserzeugung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationSachPrivatRequest" type="SubmitApplicationSachPrivatRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request Antragseinreichung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationSachPrivatResponse" type="SubmitApplicationSachPrivatResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antragseinreichung Sach-Privat</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_5_0/omds3_ON7_Schaden.xsd

@@ -0,0 +1,779 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on7schaden" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on7schaden" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.5.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds211-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<!--Schadenservices Versicherungsunternehmen -->
+	<xsd:complexType name="CheckClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für die probeweise Anlage einer Schadenmeldung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Schadenereignis" type="Schadenereignis_Type"/>
+					<xsd:element name="Dokumente" type="cst:Upload_Dokument_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Optional Dokumente die synchron im Request übermittelt werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CheckClaimRequest" type="CheckClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt einer Schadenmeldung. Die Schadenmeldung muss alle Elemente beinhalten, so dass eine Schadennummer vergeben werden kann. Dennoch sind die meisten Felder hier optional, da die notwendigen Angaben sich je nach Sparte und Anwendungsbereich des Service unterscheiden können. Die Überprüfung auf fehlende Angaben muss zur Laufzeit erfolgen.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="CheckClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Anworttyp beim Erzeugen einer Schadenmeldung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Schadenereignis" type="Schadenereignis_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn kein Fehler aufgetreten ist, ist dieses Element vorhanden und enthält zumindest eine GeschäftsfallId. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="CheckClaimResponse" type="CheckClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt beim Erzeugen einer Schadenmeldung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SubmitClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für die Durchführung einer Schadenmeldung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Schadenereignis" type="Schadenereignis_Type" minOccurs="0"/>
+					<xsd:element name="Dokumente" type="cst:Upload_Dokument_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Optional Dokumente die synchron im Request übermittelt werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="SubmitClaimRequest" type="SubmitClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt einer Schadenmeldung. Die Schadenmeldung muss alle Elemente beinhalten, so dass eine Schadennummer vergeben werden kann. Dennoch sind die meisten Felder hier optional, da die notwendigen Angaben sich je nach Sparte und Anwendungsbereich des Service unterscheiden können. Die Überprüfung auf fehlende Angaben muss zur Laufzeit erfolgen.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SubmitClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Anworttyp beim Erzeugen einer Schadenmeldung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Schadenereignis" type="Schadenereignis_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn kein Fehler aufgetreten ist, ist dieses Element vorhanden und enthält zumindest eine GeschäftsfallId. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="SubmitClaimResponse" type="SubmitClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt beim Erzeugen einer Schadenmeldung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ enthält eine Schadennr oder eine GeschaeftsfallId</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+					<xsd:choice>
+						<xsd:element ref="GeschaeftsfallSchadenereignis"/>
+						<xsd:element ref="GeschaeftsfallSchadenanlage"/>
+						<xsd:element name="Schadennr" type="omds:Schadennr">
+							<xsd:annotation>
+								<xsd:documentation>Schadennummer als omds:Schadennr</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:choice>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetClaimRequest" type="GetClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Schadenereignis</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response-Objekt für Schadenereignisse</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Schadenereignis" type="Schadenereignis_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetClaimResponse" type="GetClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabeobjekt für die Abrage von Schäden nach Schadennummer oder GeschäftsfallId</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SearchClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request-Type für die Suche nach einem Schaden</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="Suchbegriff" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Polizzennr" type="omds:Polizzennr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mögliche Einschränkung auf eine Polizzennr</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Personennr" type="omds:Personennr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mögliche Einschränkung auf eine Person, die am Schaden beteiligt ist.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mögliche Einschränkung auf einen Zeitraum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="BearbStandCd" type="BearbStandCd_Type" minOccurs="0"/>
+			<xsd:element name="MaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Maximale Anzahl von Ergebnissen, die zurückgegeben werden sollen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Offset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Offset in der Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Meldedatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="SearchClaimRequest" type="SearchClaimRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request für die Suche nach einem Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SearchClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response-Type der Suche nach einem Schaden</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="SearchClaimResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="SearchClaimResponse" type="SearchClaimResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response der Suche nach einem Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SearchClaimResponseResult_Type">
+		<xsd:annotation>
+			<xsd:documentation>Das Ergebnisobjekt der Schadensuche</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ActualOffset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Der tatsächliche Offset in der Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ActualMaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Tatsächliche Maximalanzahl der Ergebnisse, die der Provider auf eine Anfrage zurück gibt. Beispiel: Consumer fordert 1000 Ergebnisse an, Provider liefert aber maximal 100 zurück. In diesem Fall würde hier 100 zurückgegeben. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="TotalResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Gesamtzahl der Ergebnisse unter dem verwendeten Filter</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Schadenereignisse" type="SchadenereignisLight_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Leichtgewichtige Objektbäume zu den Schadenereignissen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Schadenobjekte</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="GeschaeftsfallSchadenereignis" type="cst:ObjektId_Type">
+		<xsd:annotation>
+			<xsd:documentation>GeschäftsfallId der Anlage des Schadenereignis-Objektes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="BasisSchadenereignis_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ mit gemeinsamen Rumpfdaten fuer Schadenereignis und Schadenereignis-Light</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element ref="GeschaeftsfallSchadenereignis" minOccurs="0"/>
+			<xsd:element name="NachfolgendeSchadenmeldung" type="cst:ObjektId_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ein Bezug auf eine andere Schadenmeldung bei Mehrfachmeldungen von Schäden. Wird nur im Response von GetClaim bzw. SearchClaim verwendet.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="VorherigeSchadenmeldungen" type="cst:ObjektId_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Ein Bezug auf eine vorangegangene Schadenmeldung bei Mehrfachmeldungen eines Schadenereignisses. Wird nur im Response von GetClaim bzw. SearchClaim verwendet.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Ereigniszpkt" type="omds:Datum-Zeit">
+				<xsd:annotation>
+					<xsd:documentation>Der Zeitpunkt als Datum-Zeit-Objekt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="EreignisbeschrTxt" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die Beschreibung des Schadenereignis als Text</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Meldedat" type="omds:Datum-Zeit"/>
+			<xsd:element name="DeepLink" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="ZusaetzlicheSchadensereignisdaten" type="ZusaetzlicheSchadensereignisdaten_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Meldungen" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Eine oder mehrere Meldungen zur Anfrage</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Schadenereignis_Type">
+		<xsd:annotation>
+			<xsd:documentation>Eine Beschreibung eines Schadenereignisses ohne Ids. Von diesem Type erben die Meldung und die Darstellung eines Schadenereignisses.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BasisSchadenereignis_Type">
+				<xsd:sequence>
+					<xsd:element name="SchadOrt" type="Ort_Type"/>
+					<xsd:element name="BeteiligtePersonen" type="BeteiligtePerson_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Hier wird bewusst nicht das OMDS-Objekt Schadenbeteiligter verwendet, da es bei der Meldung möglich sein muss, die Personendaten anzugeben und nicht nur auf Personen zu referenzieren.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="GeschaedigteInteressen" type="GeschaedigtesInteresse_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ein geschädigtes Interesse kann ein physisches Objekt, z.B. ein Kfz oder eine Immobilie sein. Es kann aber auch ein ideelles Gut sein. Geschädigte Interessen können im Schadenobjekt referenziert werden, müssen aber nicht referenziert werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentenReferenz_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenz auf Dokumente</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Schadenmelder" type="Schadenmelder_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Eine Kennung des Schadenmelders, z.B. eine Vermittlernummer im Falle eines Maklers</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Bankverbindung" type="cst:PersBankverbindung_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="Schaeden" type="Schaden_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die Schadenobjekte sind auf Sparten bezogen, z.B. kann ein Schadenereignis zu einem Haftpflicht, einem Kasko-Schaden führen. </xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SchadenereignisLight_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ zur leichtgewichtigen Abbildung von Schadenereignis-Objekten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BasisSchadenereignis_Type">
+				<xsd:sequence>
+					<xsd:element name="Schaeden" type="SchadenLight_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Die eigentlichen Schadenobjekte, die typischer Weise zeitverzögert vom Versicherungsunternehmen angelegt werden</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GeschaeftsfallSchadenanlage" type="cst:ObjektId_Type">
+		<xsd:annotation>
+			<xsd:documentation>GeschäftfallId der Anlage des spartenbezogenen Schaden-Objektes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="Schaden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Die Darstellung eines Schadens (spartenbezogenes Unterobjekt eines Schadenereignisses)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BasisSchaden_Type">
+				<xsd:sequence>
+					<xsd:element name="BearbStandCd" type="BearbStandCd_Type" minOccurs="0"/>
+					<xsd:element ref="Schadenzuordnung"/>
+					<xsd:element name="SchadenTxt" type="xsd:string" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Kann auch längere Beschreibungen enthalten, ist daher nicht identisch mit SchadUrsTxt in OMDS-Datensatz</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="BeteiligtePersonen" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="ReferenzAufBeteiligtePersonSchaden_Type">
+									<xsd:sequence>
+										<xsd:choice>
+											<xsd:annotation>
+												<xsd:documentation>Es kann entweder eine Vertragsrolle oder eine Schadensrolle verwendet werden.</xsd:documentation>
+											</xsd:annotation>
+											<xsd:element name="Vertragsrolle" type="omds:VtgRolleCd_Type"/>
+											<xsd:sequence>
+												<xsd:element name="Schadensrolle" type="omds:BetRolleCd_Type"/>
+												<xsd:element name="GeschInteresseLfnr" type="xsd:unsignedShort" minOccurs="0">
+													<xsd:annotation>
+														<xsd:documentation>Optional die Referenz auf ein geschädigtes Interesse.  </xsd:documentation>
+													</xsd:annotation>
+												</xsd:element>
+											</xsd:sequence>
+										</xsd:choice>
+										<xsd:element name="ZusaetzlicheRollendaten" type="ZusaetzlicheRollendaten_Type" minOccurs="0" maxOccurs="unbounded">
+											<xsd:annotation>
+												<xsd:documentation>Moeglichkeit fuer die Erweiterung des Standards um eigene Daten zur Rolle</xsd:documentation>
+											</xsd:annotation>
+										</xsd:element>
+									</xsd:sequence>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="LeistungGeschaetzt" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="WaehrungsCd" type="omds:WaehrungsCd_Type" minOccurs="0"/>
+					<xsd:element name="Spartendetails" type="SpartendetailSchaden_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>VU-übergreifende aber spartenspezifische Detailinformationen für bestimmte Sparten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SchadenLight_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ zur leichtgewichtigen Abbildung von Schadenobjekten </xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="BasisSchaden_Type">
+				<xsd:sequence>
+					<xsd:element name="BearbStandCd" type="BearbStandCd_Type"/>
+					<xsd:element ref="Schadenzuordnung" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="BasisSchaden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ mit gemeinsamen Rumpfdaten fuer Schaden und Schaden-Light </xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element ref="GeschaeftsfallSchadenanlage" minOccurs="0"/>
+			<xsd:element name="Schadennr" type="omds:Schadennr" minOccurs="0"/>
+			<xsd:element name="BearbStandSeit" type="omds:Datum" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Seit wann der Bearbeitungsstand erreicht ist</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="VormaligeSchadennr" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
+			<xsd:element name="NachfolgendeSchadennr" type="omds:Schadennr" minOccurs="0"/>
+			<xsd:element name="SachbearbVU" type="SachbearbVUType" minOccurs="0"/>
+			<xsd:element name="Polizzennr" type="omds:Polizzennr"/>
+			<xsd:element name="VertragsID" type="omds:VertragsID" minOccurs="0"/>
+			<xsd:element name="ErledDat" type="omds:Datum" minOccurs="0"/>
+			<xsd:element name="DeepLink" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="ZusaetzlicheSchadensdaten" type="ZusaetzlicheSchadensdaten_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Meldungen" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Eine oder mehrere Meldungen zu diesem Objekt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="BeteiligtePerson_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für die Meldung von Personen, die an einem Schaden beteiligt sind</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element ref="cst:Person">
+				<xsd:annotation>
+					<xsd:documentation>Objekt ähnlich zu omds:PERSON, aber Personennr ist nicht Pflichtfeld</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+		<xsd:attribute name="Lfnr" type="xsd:unsignedShort" use="required">
+			<xsd:annotation>
+				<xsd:documentation>Vergabe einer laufenden Nummer ist Pflicht. Über die Laufende Nummer kann der Schadenbeteiligte innerhalb dieses Requests (z.B. innerhalb dieser Schadenmeldung) referenziert werden.</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<xsd:complexType name="SpartendetailSchaden_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Eine Erweiterung der Schadenmeldung fuer spezielle Sparten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SpartendetailSchadenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spartenerweiterung der Schadenmeldung für Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpartendetailSchaden_Type">
+				<xsd:sequence>
+					<xsd:element name="BehoerdlichAufgenommen" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Kennzeichen" type="xsd:string"/>
+					<xsd:element name="VerschuldenCd" type="omds:VerschuldenCd_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpartendetailSchadenUnfall_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spartenerweiterung der Schadenmeldung für Unfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpartendetailSchaden_Type">
+				<xsd:sequence>
+					<xsd:element name="ArbeitsunfaehigVon" type="omds:Datum" minOccurs="0"/>
+					<xsd:element name="ArbeitsunfaehigBis" type="omds:Datum" minOccurs="0"/>
+					<xsd:element name="Diagnose" type="xsd:string"/>
+					<xsd:element name="BehandlerName" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpartendetailSchadenKranken_Type">
+		<xsd:annotation>
+			<xsd:documentation>Spartenerweiterung der Schadenmeldung für Kranken</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpartendetailSchaden_Type">
+				<xsd:sequence>
+					<xsd:element name="BehandlerName" type="xsd:string"/>
+					<xsd:element name="Behandlungen" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="BehandlungVon" type="omds:Datum"/>
+								<xsd:element name="BehandlungBis" type="omds:Datum" minOccurs="0"/>
+							</xsd:sequence>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="Ort_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schadenort</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Adresse" type="omds:ADRESSE_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Im Regelfall gibt es eine Adresse</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Beschreibung" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>In bestimmten Fällen, gibt es keine postalische Adresse, z.B. bei "Kfz-Unfall auf der A1, km 123" oder die postalische Adresse soll ergänzt werden</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Geokoordinaten" type="Geokoordinaten_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Geokoordinaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Geokoordinaten im Dezimalsystem</xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="Breite" type="xsd:double">
+			<xsd:annotation>
+				<xsd:documentation>Breite, Latitude</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="Laenge" type="xsd:double">
+			<xsd:annotation>
+				<xsd:documentation>Länge, Longitude</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaedigtesInteresse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Das geschädigte Interesse ist der Basistyp für den es Erweiterungen geben kann, z.B. das geschädigte Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Lfnr" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Eine fortlaufende Nummer, die in einem Request (z.B. einer Schadenmeldung) eindeutig ist und innerhalb dieses Requests referenziert werden kann.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="SchadenBeschreibung">
+				<xsd:annotation>
+					<xsd:documentation>Eine Beschreibung des Schadens am geschädigten Interesse und ggf. eine Beschreibung des geschädigten Interesses selbst.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="100"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaedigtesObjektKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Erweiterung des geschädigten Interesses zu einem geschädigten Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="GeschaedigtesInteresse_Type">
+				<xsd:sequence>
+					<xsd:element name="VUNrGesch" type="omds:VUNr" minOccurs="0"/>
+					<xsd:element name="VUNameGesch" type="xsd:string"/>
+					<xsd:element name="PolNrGesch" type="omds:Polizzennr"/>
+					<xsd:element name="SchadennrGesch" type="omds:Schadennr" minOccurs="0"/>
+					<xsd:element name="LandesCd_GeschKfz" type="omds:LandesCd_Type" minOccurs="0"/>
+					<xsd:element name="Kennz_GeschKfz">
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="12"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="Marke" minOccurs="0">
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:maxLength value="40"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="Handelsbez" minOccurs="0">
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="30"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="Fahrgestnr" minOccurs="0">
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:maxLength value="20"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="TypVarVer" minOccurs="0">
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="20"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GeschaedigtesObjektImmobilie_Type">
+		<xsd:annotation>
+			<xsd:documentation>Erweiterung des geschädigten Interesses zu einer geschädigten Immobilie</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="GeschaedigtesInteresse_Type">
+				<xsd:sequence>
+					<xsd:element name="GebaeudeArtCd" type="omds:GebaeudeArtCd_Type" minOccurs="0"/>
+					<xsd:element ref="cst:OrdnungsbegriffZuordFremd" minOccurs="0"/>
+					<xsd:element name="GebauedeBez" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Freitext, max. 60 Zeichen</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:maxLength value="60"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="Schadenmelder_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ um Informationen über den Melder eines Schadens zu übermitteln</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SchadenmelderVermittler_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ zur Angabe eines Vermittlers als Schadenmelder</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ObjektSpezifikation_Type">
+				<xsd:sequence>
+					<xsd:element name="Vermnr" type="omds:Vermnr"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="BearbStandCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Bearbeitungsstand Schaden (eine Erweiterung von BearbStandCd im OMDS-Datensatz)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="99">
+				<xsd:annotation>
+					<xsd:documentation>sonstiges</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="G">
+				<xsd:annotation>
+					<xsd:documentation>gemeldet - Schaden wurde gemeldet, eine Schadennummer ist noch nicht vergeben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="A">
+				<xsd:annotation>
+					<xsd:documentation>abgeschlossen ohne Zahlung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="D">
+				<xsd:annotation>
+					<xsd:documentation>Doppelanlage, bzw. irrtümlich angelegt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="E">
+				<xsd:annotation>
+					<xsd:documentation>erledigt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="K">
+				<xsd:annotation>
+					<xsd:documentation>im Klagzustand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="O">
+				<xsd:annotation>
+					<xsd:documentation>offen - zur Bearbeitung angenommen, Schadennummer vergeben, aber noch nicht weiter bearbeitet</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="T">
+				<xsd:annotation>
+					<xsd:documentation>teilweise gezahlt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="W">
+				<xsd:annotation>
+					<xsd:documentation>Schaden wiedereröffnet / reaktiviert</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="N">
+				<xsd:annotation>
+					<xsd:documentation>Kein Schaden, eine Schadennumer wird nicht vergeben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ReferenzAufBeteiligtePersonSchaden_Type">
+		<xsd:annotation>
+			<xsd:documentation>Das Zuordnungsobjekt, welches die fachliche Zuordnung eines Schadens ermöglicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="BetLfnr" type="xsd:unsignedShort" use="required">
+			<xsd:annotation>
+				<xsd:documentation>Referenz auf eine beteiligte Person</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="BetTxt">
+			<xsd:annotation>
+				<xsd:documentation>Zusätzlicher kurzer Text zur Rolle der beteiligten Person</xsd:documentation>
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:maxLength value="100"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+	</xsd:complexType>
+	<xsd:element name="Schadenzuordnung" type="SchadenzuordnungType">
+		<xsd:annotation>
+			<xsd:documentation>Die Schadenzuordnung enthält eine VU-spezifische Systematik, mit Hilfe derer die Schadenmeldung automatisch zugeordnet wird. Sie entspricht nicht dem SchadUrsCd aus dem OMDS Datensatz, da dieser allgemein über alle VUs gilt und damit keine ausreichend präzise  Zuordnung zulässt.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="SchadenzuordnungType">
+		<xsd:annotation>
+			<xsd:documentation>Typ für die Schadenzuordnung, welche eine vierstufige Systematik enthält, wobei die Schlüssel VU-spezifisch sind</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="SchadenSparteCd" type="xsd:string"/>
+			<xsd:element name="UrsacheCd" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Nicht identisch mit OMDS SchadUrsCd</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="SpezifikationCd" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="ArtGeschaedigtesObjCd" type="xsd:string" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheSchadensereignisdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung der Schadensmeldung um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheSchadensdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung von Schäden um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheRollendaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung von Rollen um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="SachbearbVUType">
+		<xsd:annotation>
+			<xsd:documentation>Typ für die Übermittlung von Kontaktdaten eines Sachbearbeiters</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Person" type="NatPerson_Type"/>
+			<xsd:element ref="omds:EL-Kommunikation" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="NatPerson_Type">
+		<xsd:annotation>
+			<xsd:documentation>Natuerliche Person</xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="Familienname" use="required"/>
+		<xsd:attribute name="Vorname"/>
+		<xsd:attribute name="GeschlechtCd" type="omds:GeschlechtCd_Type" use="required"/>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_6_0/omds3ServiceTypes.xsd

@@ -0,0 +1,681 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:omds3ServiceTypes-1-1-0" xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:omds3ServiceTypes-1-1-0" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.6.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds214-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<!-- Beziehe Action Link -->
+	<xsd:element name="loginRequest" type="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt für den Actionlink</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="LoginRequestType">
+		<xsd:annotation>
+			<xsd:documentation>Der Typ des Request-Objekts fuer den allgemeinen Portaleinstieg</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="loginResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Der Actionlink z.B. in das Maklerportal mit einem Token, der die Verbindung zur Session herstellt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<!-- Beziehe User-Daten -->
+	<xsd:element name="getUserDataRequest" type="UserDataRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Request-Objekt fuer den Zugriff auf die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die VUNr des angefragten Unternehmens. Dies ermöglicht ggf. mehrere VUs über eine technische Lösung zu servicieren. Verwendet den Typ VUNr aus OMDS-Datensatz.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getUserDataResponse" type="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Das Ergebnisobjekt fuer die Userdaten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="UserDataResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Type mit Benutzerinformationen. Das Element 'address' ist mit Version 1.1.0 entfallen, da diese Informationen auch im Element 'person' übermittelt werden können
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="userid">
+				<xsd:annotation>
+					<xsd:documentation>BenutzerId</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="availableServices">
+				<xsd:annotation>
+					<xsd:documentation>Liste der für diesen User unterstützen Services</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="service" type="xsd:string" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation>Die ServiceId des jeweiligen Webservice als String</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="person" type="omds:PERSON_Type">
+				<xsd:annotation>
+					<xsd:documentation>Ist vom Typ PERSON_Type aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste verfuegbarer OMDS-Datensaetze -->
+	<xsd:element name="getOMDSPackageListRequest" type="OMDSPackageListRequest">
+		<xsd:annotation>
+			<xsd:documentation>Inputobjekt zum Beziehen einer Liste verfuegbarer OMDS-Datensaetze</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>die VUNr aus OMDS als optionaler Filterparameter</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>von inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>bis inkl. Datum</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageListResponse" type="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabeobjekt für eine Liste von OMDS-Datensätzen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageListResponse">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ definiert eine Liste von OMDS-Datensaetzen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence minOccurs="0">
+			<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" minOccurs="0" maxOccurs="unbounded"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe einzelnen OMDS-Datensatz -->
+	<xsd:element name="getOMDSPackageRequest" type="OMDSPackageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Das Requestobjekt fuer die Abholung eines oder mehrerer OMDS-Datensatz-Packages</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="agentFilter" type="cst:AgentFilter_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Hier wird direkt ein agentFilter-Element verwendet und kein abstrakter authFilter, da dieser Service dezidiert auf Makler zugeschnitten ist und OMDS-Packages nach MaklerID und Vermittlernummer strukturiert sind und nicht nach anderen Filterkriterien.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageId" type="xsd:string" nillable="false" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Datensatzes unter welcher er ueber Webservices referenziert werden kann. Es handelt sich nicht um eine Id aus dem OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getOMDSPackageResponse" type="OMDSPackageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Gibt die Liste der angeforderten OMDS-Packages zurück oder entsprechende fachliche Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="OMDSPackageResponse">
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackage" type="RequestedOMDSPackage" nillable="false" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste der angeforderten Pakete</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="RequestedOMDSPackage">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer ein OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="requestedOmdsPackageId" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Die angefragte Id des OMDS-Datenpakets, wobei dies kein Schlüssel aus dem Paket ist. </xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="1"/>
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="omdsPackage" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Nur enthalten, wenn es das angeforderte Paket tatsächlich gibt und der User darauf berechtigt ist.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:element name="omdsPackageInfo" type="OMDSPackageInfoType" nillable="false">
+							<xsd:annotation>
+								<xsd:documentation>Meta-Informationen zu diesem Paket</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="content" type="xsd:base64Binary" xmime:expectedContentTypes="application/zip">
+							<xsd:annotation>
+								<xsd:documentation>Gezippte OMDS-Daten als base64Binary oder mit Binary mit MTOM</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:complexType>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Fachliche Fehlermeldungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="OMDSPackageInfoType">
+		<xsd:annotation>
+			<xsd:documentation>Typ fuer die wesentlichen Informationen zu einem OMDS-Datensatz-Package</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="MaklerID" type="cst:MaklerID_Type" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Entspricht der MaklerID in OMDS 2.x. Die MaklerID (in Version 1.0.0 noch AgentID) ist eine übergeordnete ID des Vermittlers unter welcher mehrere Vermittlernummern zusammengefasst sein können. Diese ID ist in der Regel spezifisch für die jeweilige VU oder den jeweiligen Dienstleister, bei dem die Daten abgeholt werden. Ein zulässiger Spezialfall ist, dass die agentID mit der Vermittlernummer "Vermnr" (in Version 1.0.0 noch agentNumber) zusammenfällt.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="omdsPackageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des OMDS Pakets und Angaben zu ihrer Verwendbarkeit, wobei hier kein Schlüssel aus einem OMDS Paket selbst gemeint ist, sondern eine eigenständige Id, die das Abrufen des OMDS-Pakets ermöglicht.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="timeStamp" type="omds:Datum-Zeit" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Zeitstempel der Erstellung entsprechend dem Attribut PaketZpktErstell mit OMDS Datum-Zeit als Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageSize" type="xsd:int" nillable="false">
+				<xsd:annotation>
+					<xsd:documentation>Groesse der Datei in Byte, de facto beschränkt auf max. ca. 2 GB da vom Typ int</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageExtent" type="omds:PaketUmfCd_Type">
+				<xsd:annotation>
+					<xsd:documentation>entspricht dem der Paketumfang wie er in OMDS 2.x im Typ PaketUmfCd_Type definiert ist: D = Differenz, G = Gesamtbestand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="packageContentCode" type="omds:PaketInhCd_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste von OMDS 2.x Elementen des Typs PaketInhCd_Type, die den Inhalt des Datenpakets beschreiben</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe eine Liste vertragsbezogener Dokumente -->
+	<xsd:element name="getArcImageInfosRequest" type="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfrage Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosRequest">
+		<xsd:annotation>
+			<xsd:documentation>Anfragetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>die Polizzennummer als OMDS Polizzennr-Typ.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyType" type="omds:VtgProdCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für Polizzen eines bestimmten Typs. Das Attribut ist vom Typ VtgProdCd_Type des OMDS-Datensatz</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="policyPartnerRole" type="PolicyPartnerRole" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf Dokumente für bestimmte Partner in einer bestimmten Rolle</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Einschränkung der Anfrage auf bestimmte Dokumententypen. Es gibt 15 definierte vertragsbezogene Dokumententypen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="dateFrom" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="dateUntil" type="xsd:date" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageInfosResponse" type="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabe Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageInfosResponse">
+		<xsd:annotation>
+			<xsd:documentation>Rückgabetyp Informationen zu vertragsbezogenen Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Informationen zu Dokumenten, wenn vorhanden</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageRequest" type="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Request zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requesttyp zur Abholung eines einzelnen bekannten Dokuments</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>ermöglicht "Super-Usern" die Abfrage von spezifischen Elementen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArcImageId">
+				<xsd:annotation>
+					<xsd:documentation>Die Id des Dokuments vom Typ String</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<!--<xsd:element name="policy" type="Policy"/>-->
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getArcImageResponse" type="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="ArcImageResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responsetyp zur Rückgabe eines einzelnen Dokumentes</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ArcContent" type="ArcContent" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Das Dokument und seine Meta-Informationen, wenn ein Dokument vorhanden war</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="PolicyPartnerRole">
+		<xsd:annotation>
+			<xsd:documentation>Partnerrollen in einer Polizze: Versicherungsnehmer, Versicherte Person</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS-Personennr (String mit 1-26 Zeichen) </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="partnerRole" type="cst:PartnerRoleType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Partnerrollen im Vertrag als PartnerRoleType: String mit 2 Zeichen: VN, VP</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcImageInfo">
+		<xsd:annotation>
+			<xsd:documentation>Information zu einem einzelnen Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageIdDetails" type="cst:ElementIdType">
+				<xsd:annotation>
+					<xsd:documentation>Die eindeutige Id des Dokuments und Details zur Verwendung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="name" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Der Name des Dokuments als String</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="documentType" type="cst:DocumentType">
+				<xsd:annotation>
+					<xsd:documentation>Der inhaltliche Typ des Dokuments, z.B. "Polizze" oder "Finanzamtsbestätigung" als Integer-Code</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentType" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Mime-Type des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcContentLength" type="xsd:long" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Größe des Dokuments in Byte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="date" type="xsd:date">
+				<xsd:annotation>
+					<xsd:documentation>Erstellungsdatum des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="docReference" type="ArcImageInfo" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Verweis auf weitere Dokumente, die inhaltlich zu diesem Dokument gehören, z.B. AVB zu einer Polizze</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="ArcContent">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument und das Dokument base64encoded</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="arcImageInfo" type="ArcImageInfo">
+				<xsd:annotation>
+					<xsd:documentation>Meta-Informationen zum Dokument</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="arcImage" type="xsd:base64Binary" xmime:expectedContentTypes="application/octet-stream">
+				<xsd:annotation>
+					<xsd:documentation>Das eigentliche Dokument als base64-Binary</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- Beziehe Deep-Links -->
+	<xsd:element name="getDeepLinkClaimRequest" type="DeepLinkClaimRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Schaden Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkClaimRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="claimNumber" type="omds:Schadennr">
+				<xsd:annotation>
+					<xsd:documentation>Schadennummer vom Typ OMDS Schadennr</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkClaimResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt Deep-Link Schaden</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPartnerRequest" type="DeepLinkPartnerRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPartnerRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="partnerNumber" type="omds:Personennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Partnernummer als OMDS Personennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPartnerResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Partner Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkOfferRequest" type="DeepLinkOfferRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot/ Antrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkOfferRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="offerNumber" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer der Berechnung, des Angebots oder des Antrags.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkOfferResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Angebot / Antrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkPolicyRequest" type="DeepLinkPolicyRequest">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Anfrage</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="DeepLinkPolicyRequest">
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr" minOccurs="0"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="policyNumber" type="omds:Polizzennr">
+				<xsd:annotation>
+					<xsd:documentation>Die Nummer des Vertrags als OMDS Polizzennr-Typ</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element ref="withoutFrame" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="getDeepLinkPolicyResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Deep-Link Vertrag Antwort</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="getDeepLinkBusinessObjectResponse" type="DeepLinkBusinessObjectResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response Deep-Link auf Geschäftsobjekte</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="withoutFrame" type="xsd:boolean">
+		<xsd:annotation>
+			<xsd:documentation>Soll ein Frame angezeigt werden oder nicht</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="httpActionLink" type="HttpActionLinkType"/>
+	<xsd:complexType name="HttpActionLinkType">
+		<xsd:annotation>
+			<xsd:documentation>Definiert einen Deep-Link</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="url">
+				<xsd:annotation>
+					<xsd:documentation>String mit max. 1024 Zeichen</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:maxLength value="1024"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="type">
+				<xsd:annotation>
+					<xsd:documentation>Code für Art der URL, z.B. Verträge, Dokumente, Schäden, Schadenmeldung als int-Type.</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:int">
+						<xsd:enumeration value="1">
+							<xsd:annotation>
+								<xsd:documentation>Einstiegsseite</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="2">
+							<xsd:annotation>
+								<xsd:documentation>Suche Partner</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="3">
+							<xsd:annotation>
+								<xsd:documentation>Suche Vertrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="4">
+							<xsd:annotation>
+								<xsd:documentation>Suche Schaden</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="5">
+							<xsd:annotation>
+								<xsd:documentation>Suche Angebot/Antrag</xsd:documentation>
+								<!-- in 1.03 Deep-Link allgemein -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="6">
+							<xsd:annotation>
+								<xsd:documentation>Schadenübersicht</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden, keine Doublette zu Nr 12, da hier Übersicht über einzelnen Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="7">
+							<xsd:annotation>
+								<xsd:documentation>Dokumente</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="8">
+							<xsd:annotation>
+								<xsd:documentation>Anfrage</xsd:documentation>
+								<!-- in 7.01 Deep-Link-Schaden -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="9">
+							<xsd:annotation>
+								<xsd:documentation>Stammdaten</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="10">
+							<xsd:annotation>
+								<xsd:documentation>Bearbeiten</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="11">
+							<xsd:annotation>
+								<xsd:documentation>Verträge</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="12">
+							<xsd:annotation>
+								<xsd:documentation>Schäden</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag, in 4.01 Deep-Link-Partner, Keine Doublette zu Nr 6 da hier eine Liste von Schäden zu einem gegebenen Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="13">
+							<xsd:annotation>
+								<xsd:documentation>Angebote</xsd:documentation>
+								<!-- in 4.01 Deep-Link-Partner, keine Doublette zu Nr 14 Angebots-/ Antragsübersicht, da hier nur Angebote des Partners -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="14">
+							<xsd:annotation>
+								<xsd:documentation>Angebots-/ Antragsübersicht</xsd:documentation>
+								<!-- in 2.01 Deep-Link-Angebot-Antrag, keine Doublette zu Nr 13, da hier Übersichtsseite über alle Angebote/ Anträge des Service-Konsumenten -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="15">
+							<xsd:annotation>
+								<xsd:documentation>Inkassostand</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="16">
+							<xsd:annotation>
+								<xsd:documentation>Angebot</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="17">
+							<xsd:annotation>
+								<xsd:documentation>Schadenmeldung</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="18">
+							<xsd:annotation>
+								<xsd:documentation>Mahnungen</xsd:documentation>
+								<!-- in 3.03 Deep-Link-Vertrag -->
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="validUntil" type="xsd:dateTime" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ablaufzeitpunkt der Action-Links. Wenn Actionslinks vorhanden sind, dieses Element jedoch nicht oder mit dem Wert "null", so sind die ActionLinks zeitlich unbeschränkt gültig. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="DeepLinkBusinessObjectResponse">
+		<xsd:sequence>
+			<xsd:element name="httpActionLink" type="HttpActionLinkType" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Linkbeschreibung vom Typ LinkType</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_6_0/omds3Services.wsdl

@@ -0,0 +1,747 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Release 1.6.0 -->
+<definitions name="omds3Services-1-4-0" targetNamespace="urn:omds3Services-1-4-0"
+xmlns:os="urn:omds3Services-1-4-0"
+xmlns:ost="urn:omds3ServiceTypes-1-1-0"
+xmlns:cst="urn:omds3CommonServiceTypes-1-1-0"
+xmlns:b="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen"
+xmlns:boak="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz"
+xmlns:boaSp="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat"
+xmlns:sch="urn:at.vvo.omds.types.omds3types.v1-4-0.on7schaden"
+xmlns="http://schemas.xmlsoap.org/wsdl/"
+xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
+xmlns:ns="http://www.w3.org/2001/XMLSchema"
+xmlns:ns1="http://schemas.xmlsoap.org/soap/encoding/"
+xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+	<types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema">
+			<import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" schemaLocation="omds3_ON1_Basisfunktionen.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" schemaLocation="omds3_ON2_Antrag_Kfz.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.sachprivat" schemaLocation="omds3_ON2_Antrag_SachPrivat.xsd"/>
+			<import namespace="urn:at.vvo.omds.types.omds3types.v1-4-0.on7schaden" schemaLocation="omds3_ON7_Schaden.xsd"/>
+		</schema>
+	</types>
+	<message name="loginRequest">
+		<part name="parameters" element="ost:loginRequest"/>
+	</message>
+	<message name="loginResponse">
+		<part name="parameters" element="ost:loginResponse"/>
+	</message>
+
+	<message name="getUserDataRequest">
+		<part name="parameters" element="ost:getUserDataRequest"/>
+	</message>
+	<message name="getUserDataResponse">
+		<part name="parameters" element="ost:getUserDataResponse"/>
+	</message>
+
+	<message name="getOMDSPackageListRequest">
+		<part name="parameters" element="ost:getOMDSPackageListRequest"/>
+	</message>
+	<message name="getOMDSPackageListResponse">
+		<part name="parameters" element="ost:getOMDSPackageListResponse" />
+	</message>
+
+	<message name="getOMDSPackageRequest">
+		<part name="parameters" element="ost:getOMDSPackageRequest"/>
+	</message>
+	<message name="getOMDSPackageResponse">
+		<part name="parameters" element="ost:getOMDSPackageResponse" />
+	</message>
+
+	<!-- Vertragsbezogene Dokumente -->
+
+	<message name="getArcImageInfosRequest">
+		<part name="parameters" element="ost:getArcImageInfosRequest"/>
+	</message>
+	<message name="getArcImageInfosResponse">
+		<part name="parameters" element="ost:getArcImageInfosResponse" />
+	</message>
+	<message name="getArcImageRequest">
+		<part name="parameters" element="ost:getArcImageRequest"/>
+	</message>
+	<message name="getArcImageResponse">
+		<part name="parameters" element="ost:getArcImageResponse" />
+	</message>
+
+	<!-- Dokumente allgemein -->
+	<message name="AddDocToBusinessCaseRequestMsg">
+		<part name="parameters" element="b:AddDocToBusinessCaseRequest"/>
+	</message>
+	<message name="AddDocToBusinessCaseResponseMsg">
+		<part name="parameters" element="b:AddDocToBusinessCaseResponse" />
+	</message>
+	<message name="GetNumberOfDocumentsRequestMsg">
+		<part name="parameters" element="b:GetNumberOfDocumentsRequest"/>
+	</message>
+	<message name="GetNumberOfDocumentsResponseMsg">
+		<part name="parameters" element="b:GetNumberOfDocumentsResponse" />
+	</message>
+	<message name="GetDocumentsOfObjectRequestMsg">
+		<part name="parameters" element="b:GetDocumentsOfObjectRequest"/>
+	</message>
+	<message name="GetDocumentsOfObjectResponseMsg">
+		<part name="parameters" element="b:GetDocumentsOfObjectResponse" />
+	</message>
+	<message name="GetDocumentsOfPeriodRequestMsg">
+		<part name="parameters" element="b:GetDocumentsOfPeriodRequest"/>
+	</message>
+	<message name="GetDocumentsOfPeriodResponseMsg">
+		<part name="parameters" element="b:GetDocumentsOfPeriodResponse" />
+	</message>
+
+	<!-- Deep Links -->
+
+	<message name="deepLinkClaimRequest">
+		<part name="parameters" element="ost:getDeepLinkClaimRequest"/>
+	</message>
+	<message name="deepLinkClaimResponse">
+		<part name="parameters" element="ost:getDeepLinkClaimResponse" />
+	</message>
+
+	<message name="deepLinkPartnerRequest">
+		<part name="parameters" element="ost:getDeepLinkPartnerRequest"/>
+	</message>
+	<message name="deepLinkPartnerResponse">
+		<part name="parameters" element="ost:getDeepLinkPartnerResponse" />
+	</message>
+	<message name="deepLinkOfferRequest">
+		<part name="parameters" element="ost:getDeepLinkOfferRequest"/>
+	</message>
+	<message name="deepLinkOfferResponse">
+		<part name="parameters" element="ost:getDeepLinkOfferResponse" />
+	</message>
+	<message name="deepLinkPolicyRequest">
+		<part name="parameters" element="ost:getDeepLinkPolicyRequest"/>
+	</message>
+	<message name="deepLinkPolicyResponse">
+		<part name="parameters" element="ost:getDeepLinkPolicyResponse" />
+	</message>
+
+	<!-- Schaden -->
+	<message name="CheckClaimRequestMsg">
+		<part name="parameters" element="sch:CheckClaimRequest"/>
+	</message>
+	<message name="CheckClaimResponseMsg">
+		<part name="parameters" element="sch:CheckClaimResponse" />
+	</message>
+	<message name="SubmitClaimRequestMsg">
+		<part name="parameters" element="sch:SubmitClaimRequest"/>
+	</message>
+	<message name="SubmitClaimResponseMsg">
+		<part name="parameters" element="sch:SubmitClaimResponse" />
+	</message>
+	<message name="GetClaimRequestMsg">
+		<part name="parameters" element="sch:GetClaimRequest"/>
+	</message>
+	<message name="GetClaimResponseMsg">
+		<part name="parameters" element="sch:GetClaimResponse" />
+	</message>
+	<message name="SearchClaimRequestMsg">
+		<part name="parameters" element="sch:SearchClaimRequest"/>
+	</message>
+	<message name="SearchClaimResponseMsg">
+		<part name="parameters" element="sch:SearchClaimResponse" />
+	</message>
+
+	<!-- Kraftfahrt -->
+	<message name="CalculateKfzRequestMsg">
+		<part name="parameters" element="boak:CalculateKfzRequest"/>
+	</message>
+	<message name="CalculateKfzResponseMsg">
+		<part name="parameters" element="boak:CalculateKfzResponse"/>
+	</message>
+	<message name="CreateOfferKfzRequestMsg">
+		<part name="parameters" element="boak:CreateOfferKfzRequest"/>
+	</message>
+	<message name="CreateOfferKfzResponseMsg">
+		<part name="parameters" element="boak:CreateOfferKfzResponse"/>
+	</message>
+	<message name="CreateApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzRequest"/>
+	</message>
+	<message name="CreateApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:CreateApplicationKfzResponse"/>
+	</message>
+	<message name="SubmitApplicationKfzRequestMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzRequest"/>
+	</message>
+	<message name="SubmitApplicationKfzResponseMsg">
+		<part name="parameters" element="boak:SubmitApplicationKfzResponse"/>
+	</message>
+
+	<!-- SachPrivat -->
+	<message name="CalculateSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:CalculateSachPrivatRequest"/>
+	</message>
+	<message name="CalculateSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:CalculateSachPrivatResponse"/>
+	</message>
+	<message name="CreateOfferSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:CreateOfferSachPrivatRequest"/>
+	</message>
+	<message name="CreateOfferSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:CreateOfferSachPrivatResponse"/>
+	</message>
+	<message name="CreateApplicationSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:CreateApplicationSachPrivatRequest"/>
+	</message>
+	<message name="CreateApplicationSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:CreateApplicationSachPrivatResponse"/>
+	</message>
+	<message name="SubmitApplicationSachPrivatRequestMsg">
+		<part name="parameters" element="boaSp:SubmitApplicationSachPrivatRequest"/>
+	</message>
+	<message name="SubmitApplicationSachPrivatResponseMsg">
+		<part name="parameters" element="boaSp:SubmitApplicationSachPrivatResponse"/>
+	</message>
+
+	<!-- Fehler -->
+	<message name="ServiceFaultMsg">
+		<part name="parameters" element="cst:serviceFault" />
+	</message>
+
+
+	<portType name="omdsServicePortType">
+
+		<operation name="login">
+			<input name="loginRequest" message="os:loginRequest" />
+			<output name="loginResponse" message="os:loginResponse" />
+            <fault name="loginFault" message="os:ServiceFaultMsg" />
+        </operation>
+
+		<operation name="getUserData">
+			<input name="getUserDataRequest" message="os:getUserDataRequest" />
+			<output name="getUserDataResponse" message="os:getUserDataResponse" />
+			<fault name="getUserDataFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<input name="getOMDSPackageListRequest" message="os:getOMDSPackageListRequest" />
+			<output name="getOMDSPackageListResponse" message="os:getOMDSPackageListResponse" />
+			<fault name="getOMDSPackageListFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<input name="getOMDSPackageRequest" message="os:getOMDSPackageRequest" />
+			<output name="getOMDSPackageResponse" message="os:getOMDSPackageResponse" />
+			<fault name="getOMDSPackageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImageInfos">
+			<input name="getArcImageInfosRequest" message="os:getArcImageInfosRequest" />
+			<output name="getArcImageInfosResponse" message="os:getArcImageInfosResponse" />
+			<fault name="getArcImageInfosFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="getArcImage">
+			<input name="getArcImageRequest" message="os:getArcImageRequest" />
+			<output name="getArcImageResponse" message="os:getArcImageResponse" />
+			<fault name="getArcImageFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkClaim">
+			<input name="deepLinkClaimRequest" message="os:deepLinkClaimRequest" />
+			<output name="deepLinkClaimResponse" message="os:deepLinkClaimResponse" />
+			<fault name="deepLinkClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<input name="deepLinkPartnerRequest" message="os:deepLinkPartnerRequest" />
+			<output name="deepLinkPartnerResponse" message="os:deepLinkPartnerResponse" />
+			<fault name="deepLinkPartnerFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<input name="deepLinkOfferRequest" message="os:deepLinkOfferRequest" />
+			<output name="deepLinkOfferResponse" message="os:deepLinkOfferResponse" />
+			<fault name="deepLinkOfferFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<input name="deepLinkPolicyRequest" message="os:deepLinkPolicyRequest" />
+			<output name="deepLinkPolicyResponse" message="os:deepLinkPolicyResponse" />
+			<fault name="deepLinkPolicyFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+
+		<operation name="addDocToBusinessCase">
+			<input name="AddDocToBusinessCaseRequestPort" message="os:AddDocToBusinessCaseRequestMsg" />
+			<output name="AddDocToBusinessCaseResponsePort" message="os:AddDocToBusinessCaseResponseMsg" />
+			<fault name="AddDocToBusinessCaseFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getNumberOfDocuments">
+			<input name="GetNumberOfDocumentsRequestPort" message="os:GetNumberOfDocumentsRequestMsg" />
+			<output name="GetNumberOfDocumentsResponsePort" message="os:GetNumberOfDocumentsResponseMsg" />
+			<fault name="GetNumberOfDocumentsFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentsOfObject">
+			<input name="GetDocumentsOfObjectRequestPort" message="os:GetDocumentsOfObjectRequestMsg" />
+			<output name="GetDocumentsOfObjectResponsePort" message="os:GetDocumentsOfObjectResponseMsg" />
+			<fault name="GetDocumentsOfObjectFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getDocumentsOfPeriod">
+			<input name="GetDocumentsOfPeriodRequestPort" message="os:GetDocumentsOfPeriodRequestMsg" />
+			<output name="GetDocumentsOfPeriodResponsePort" message="os:GetDocumentsOfPeriodResponseMsg" />
+			<fault name="GetDocumentsOfPeriodFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="checkClaim">
+			<input name="CheckClaimRequestPort" message="os:CheckClaimRequestMsg" />
+			<output name="CheckClaimResponsePort" message="os:CheckClaimResponseMsg" />
+			<fault name="CheckClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="submitClaim">
+			<input name="SubmitClaimRequestPort" message="os:SubmitClaimRequestMsg" />
+			<output name="SubmitClaimResponsePort" message="os:SubmitClaimResponseMsg" />
+			<fault name="SubmitClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="getClaim">
+			<input name="GetClaimRequestPort" message="os:GetClaimRequestMsg" />
+			<output name="GetClaimResponsePort" message="os:GetClaimResponseMsg" />
+			<fault name="GetClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+		<operation name="searchClaim">
+			<input name="SearchClaimRequestPort" message="os:SearchClaimRequestMsg" />
+			<output name="SearchClaimResponsePort" message="os:SearchClaimResponseMsg" />
+			<fault name="SearchClaimFault" message="os:ServiceFaultMsg" />
+		</operation>
+
+		<operation name="calculateKfz">
+			<input name="CalculateKfzRequestPort" message="os:CalculateKfzRequestMsg"/>
+			<output name="CalculateKfzResponsePort" message="os:CalculateKfzResponseMsg"/>
+			<fault name="CalculateKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createOfferKfz">
+			<input name="CreateOfferKfzRequestPort" message="os:CreateOfferKfzRequestMsg"/>
+			<output name="CreateOfferKfzResponsePort" message="os:CreateOfferKfzResponseMsg"/>
+			<fault name="CreateOfferKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createApplicationKfz">
+			<input name="CreateApplicationKfzRequestPort" message="os:CreateApplicationKfzRequestMsg"/>
+			<output name="CreateApplicationKfzResponsePort" message="os:CreateApplicationKfzResponseMsg"/>
+			<fault name="CreateApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<input name="SubmitApplicationKfzRequestPort" message="os:SubmitApplicationKfzRequestMsg"/>
+			<output name="SubmitApplicationKfzResponsePort" message="os:SubmitApplicationKfzResponseMsg"/>
+			<fault name="SubmitApplicationKfzFault" message="os:ServiceFaultMsg"/>
+		</operation>
+
+		<operation name="calculateSachPrivat">
+			<input name="CalculateSachPrivatRequestPort" message="os:CalculateSachPrivatRequestMsg"/>
+			<output name="CalculateSachPrivatResponsePort" message="os:CalculateSachPrivatResponseMsg"/>
+			<fault name="CalculateSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createOfferSachPrivat">
+			<input name="CreateOfferSachPrivatRequestPort" message="os:CreateOfferSachPrivatRequestMsg"/>
+			<output name="CreateOfferSachPrivatResponsePort" message="os:CreateOfferSachPrivatResponseMsg"/>
+			<fault name="CreateOfferSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="createApplicationSachPrivat">
+			<input name="CreateApplicationSachPrivatRequestPort" message="os:CreateApplicationSachPrivatRequestMsg"/>
+			<output name="CreateApplicationSachPrivatResponsePort" message="os:CreateApplicationSachPrivatResponseMsg"/>
+			<fault name="CreateApplicationSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+		<operation name="submitApplicationSachPrivat">
+			<input name="SubmitApplicationSachPrivatRequestPort" message="os:SubmitApplicationSachPrivatRequestMsg"/>
+			<output name="SubmitApplicationSachPrivatResponsePort" message="os:SubmitApplicationSachPrivatResponseMsg"/>
+			<fault name="SubmitApplicationSachPrivatFault" message="os:ServiceFaultMsg"/>
+		</operation>
+
+	</portType>
+
+	<binding name="omdsServicePortBinding" type="os:omdsServicePortType">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+
+
+		<!-- Referenz auf jeweilige Security Policy für alle Methoden, in diesem Fall eine UsernameToken-Policy -->
+ 		<wsp:PolicyReference URI="#OMDSUsernameTokenPolicy" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"/>
+
+
+		<operation name="login">
+			<soap:operation soapAction="urn:login" style="document" />
+			<input name="loginRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="loginResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="loginFault">
+				<soap:fault name="loginFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getUserData">
+			<soap:operation soapAction="urn:getUserData" style="document" />
+			<input name="getUserDataRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getUserDataResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getUserDataFault">
+				<soap:fault name="getUserDataFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackageList">
+			<soap:operation soapAction="urn:getOMDSPackageList" style="document" />
+			<input name="getOMDSPackageListRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageListResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageListFault">
+				<soap:fault name="getOMDSPackageListFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getOMDSPackage">
+			<soap:operation soapAction="urn:getOMDSPackage" style="document" />
+			<input name="getOMDSPackageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getOMDSPackageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getOMDSPackageFault">
+				<soap:fault name="getOMDSPackageFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Vertragsbezogene Dokumente ArcImage -->
+
+		<operation name="getArcImageInfos">
+			<soap:operation soapAction="urn:getArcImageInfos" style="document" />
+			<input name="getArcImageInfosRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageInfosResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageInfosFault">
+				<soap:fault name="getArcImageInfosFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getArcImage">
+			<soap:operation soapAction="urn:getArcImage" style="document" />
+			<input name="getArcImageRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="getArcImageResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="getArcImageFault">
+				<soap:fault name="getArcImageFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Deep-Links -->
+
+		<operation name="deepLinkClaim">
+			<soap:operation soapAction="urn:deepLinkClaim" style="document" />
+			<input name="deepLinkClaimRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkClaimResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkClaimFault">
+				<soap:fault name="deepLinkClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkPartner">
+			<soap:operation soapAction="urn:deepLinkPartner" style="document" />
+			<input name="deepLinkPartnerRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPartnerResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPartnerFault">
+				<soap:fault name="deepLinkPartnerFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkOffer">
+			<soap:operation soapAction="urn:deepLinkOffer" style="document" />
+			<input name="deepLinkOfferRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkOfferResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkOfferFault">
+				<soap:fault name="deepLinkOfferFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="deepLinkPolicy">
+			<soap:operation soapAction="urn:deepLinkPolicy" style="document" />
+			<input name="deepLinkPolicyRequest">
+				<soap:body use="literal" />
+			</input>
+			<output name="deepLinkPolicyResponse">
+				<soap:body use="literal" />
+			</output>
+			<fault name="deepLinkPolicyFault">
+				<soap:fault name="deepLinkPolicyFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Dokumentenhandling -->
+
+		<operation name="addDocToBusinessCase">
+			<soap:operation soapAction="urn:addDocToBusinessCase" style="document" />
+			<input name="AddDocToBusinessCaseRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="AddDocToBusinessCaseResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="AddDocToBusinessCaseFault">
+				<soap:fault name="AddDocToBusinessCaseFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getNumberOfDocuments">
+			<soap:operation soapAction="urn:getNumberOfDocuments" style="document" />
+			<input name="GetNumberOfDocumentsRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetNumberOfDocumentsResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetNumberOfDocumentsFault">
+				<soap:fault name="GetNumberOfDocumentsFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getDocumentsOfObject">
+			<soap:operation soapAction="urn:getDocumentsOfObject" style="document" />
+			<input name="GetDocumentsOfObjectRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentsOfObjectResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentsOfObjectFault">
+				<soap:fault name="GetDocumentsOfObjectFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getDocumentsOfPeriod">
+			<soap:operation soapAction="urn:getDocumentsOfPeriod" style="document" />
+			<input name="GetDocumentsOfPeriodRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetDocumentsOfPeriodResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetDocumentsOfPeriodFault">
+				<soap:fault name="GetDocumentsOfPeriodFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- Schaden -->
+		<operation name="checkClaim">
+			<soap:operation soapAction="urn:checkClaim" style="document" />
+			<input name="CheckClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="CheckClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="CheckClaimFault">
+				<soap:fault name="CheckClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="submitClaim">
+			<soap:operation soapAction="urn:submitClaim" style="document" />
+			<input name="SubmitClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SubmitClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SubmitClaimFault">
+				<soap:fault name="SubmitClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="getClaim">
+			<soap:operation soapAction="urn:getClaim" style="document" />
+			<input name="GetClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="GetClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="GetClaimFault">
+				<soap:fault name="GetClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<operation name="searchClaim">
+			<soap:operation soapAction="urn:searchClaim" style="document" />
+			<input name="SearchClaimRequestPort">
+				<soap:body use="literal" />
+			</input>
+			<output name="SearchClaimResponsePort">
+				<soap:body use="literal" />
+			</output>
+			<fault name="SearchClaimFault">
+				<soap:fault name="SearchClaimFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- KFZ -->
+		<operation name="calculateKfz">
+			<soap:operation soapAction="urn:calculateKfz" style="document"/>
+			<input name="CalculateKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CalculateKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CalculateKfzFault">
+				<soap:fault name="CalculateKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createOfferKfz">
+			<soap:operation soapAction="urn:createOfferKfz" style="document"/>
+			<input name="CreateOfferKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateOfferKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateOfferKfzFault">
+				<soap:fault name="CreateOfferKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createApplicationKfz">
+			<soap:operation soapAction="urn:createApplicationKfz" style="document"/>
+			<input name="CreateApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateApplicationKfzFault">
+				<soap:fault name="CreateApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="submitApplicationKfz">
+			<soap:operation soapAction="urn:submitApplicationKfz" style="document"/>
+			<input name="SubmitApplicationKfzRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="SubmitApplicationKfzResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="SubmitApplicationKfzFault">
+				<soap:fault name="SubmitApplicationKfzFault" use="literal"/>
+			</fault>
+		</operation>
+
+		<!-- SachPrivat -->
+		<operation name="calculateSachPrivat">
+			<soap:operation soapAction="urn:calculateSachPrivat" style="document"/>
+			<input name="CalculateSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CalculateSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CalculateSachPrivatFault">
+				<soap:fault name="CalculateSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createOfferSachPrivat">
+			<soap:operation soapAction="urn:createOfferSachPrivat" style="document"/>
+			<input name="CreateOfferSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateOfferSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateOfferSachPrivatFault">
+				<soap:fault name="CreateOfferSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="createApplicationSachPrivat">
+			<soap:operation soapAction="urn:createApplicationSachPrivat" style="document"/>
+			<input name="CreateApplicationSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="CreateApplicationSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="CreateApplicationSachPrivatFault">
+				<soap:fault name="CreateApplicationSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+		<operation name="submitApplicationSachPrivat">
+			<soap:operation soapAction="urn:submitApplicationSachPrivat" style="document"/>
+			<input name="SubmitApplicationSachPrivatRequestPort">
+				<soap:body use="literal"/>
+			</input>
+			<output name="SubmitApplicationSachPrivatResponsePort">
+				<soap:body use="literal"/>
+			</output>
+			<fault name="SubmitApplicationSachPrivatFault">
+				<soap:fault name="SubmitApplicationSachPrivatFault" use="literal"/>
+			</fault>
+		</operation>
+
+	</binding>
+
+	<service name="omdsService">
+		<port name="omdsServicePort" binding="os:omdsServicePortBinding">
+			<soap:address location="http://localhost:80/omdsServicePort" />
+		</port>
+	</service>
+
+
+	<wsp:Policy wsu:Id="OMDSUsernameTokenPolicy" xmlns:wsp="http://www.w3.org/ns/ws-policy"
+	    xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+	    xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
+		<wsp:ExactlyOne>
+			<wsp:All>
+				<!-- Def HTTPS: Erzwingt Ende-zu-Ende Verschluesselung -->
+				<!-- Dies muss allerdings nur aktiviert werden, wenn nicht andere Infrastruktur eine sichere Https-Verbindung gewaehrleistet -->
+				<sp:TransportBinding>
+					<wsp:Policy>
+						<sp:TransportToken>
+							<wsp:Policy>
+								<sp:HttpsToken RequireClientCertificate="false"/>
+							</wsp:Policy>
+						</sp:TransportToken>
+					</wsp:Policy>
+				</sp:TransportBinding>
+
+				<!-- schreibe Username-Token mit Passwort-Digest (Hash) vor -->
+				<sp:SupportingTokens>
+					<wsp:Policy>
+						<sp:UsernameToken sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient">
+							<wsp:Policy>
+								<sp:HashPassword/>
+							</wsp:Policy>
+						</sp:UsernameToken>
+					</wsp:Policy>
+				</sp:SupportingTokens>
+			</wsp:All>
+		</wsp:ExactlyOne>
+	</wsp:Policy>
+
+
+</definitions>

client-lib/src/main/resources/def/r1_6_0/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on1basisfunktionen" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.6.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds214-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:element name="AddDocToBusinessCaseRequest" type="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts, um Dokument zu Geschäftsfall hinzuzufügen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="Geschaeftsfallnummer" type="cst:ObjektId_Type"/>
+			<xsd:element name="Dokument" type="cst:Upload_Dokument_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="AddDocToBusinessCaseResponse" type="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="AddDocToBusinessCaseResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response von der VU, wenn ein zusätzliches Dokument übergeben wurde</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice maxOccurs="unbounded">
+			<xsd:element name="DocRef" type="cst:DokumentenReferenz_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsRequest" type="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um eine Anzahl von Dokumenten zu einem fachlichen Objekt zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Dieser Typ enthält die Elemente fuer die Anfrage nach Dokumenten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type">
+				<xsd:annotation>
+					<xsd:documentation>ObjektSpezifikation kann ab Version 1.3 entfallen, es kann aber sein, dass das Versicherungsunternehmen einen Fehler meldet, weil es Anfragen nur mit Objektspezifikation unterstützt oder weil die Ergebnismenge zu groß wäre.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetNumberOfDocumentsResponse" type="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response mit einer Anzahl von Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetNumberOfDocumentsResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="AnzDokumente" type="xsd:nonNegativeInteger"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectRequest" type="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines fachlichen Objekts zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten zu einem fachlichen Objekt</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type" minOccurs="0"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfObjectResponse" type="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines fachlichen Objekts</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfObjectResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines fachlichen Objekts.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodRequest" type="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request um Informationen zu den Dokumenten eines Zeitraums zu erhalten</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Elementen fuer die Anfrage nach Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="VUNr" type="omds:VUNr"/>
+			<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0"/>
+			<xsd:element name="ObjektSpezifikation" type="cst:ObjektSpezifikation_Type" minOccurs="0"/>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+			<xsd:element name="DokumentType" type="cst:DocumentType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Filter nach Art des Dokuments</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="MaxResults" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="Offset" type="xsd:unsignedShort" minOccurs="0"/>
+			<xsd:element name="OrderBy" minOccurs="0">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Erstellungsdatum aufsteigend"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:element name="GetDocumentsOfPeriodResponse" type="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="GetDocumentsOfPeriodResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ mit Informationen zu den Dokumenten eines Zeitraums</xsd:documentation>
+		</xsd:annotation>
+		<xsd:choice>
+			<xsd:element name="Result" type="DocumentInfosResponseResult_Type"/>
+			<xsd:element name="ServiceFault" type="cst:ServiceFault" maxOccurs="unbounded"/>
+		</xsd:choice>
+	</xsd:complexType>
+	<xsd:complexType name="DocumentInfosResponseResult_Type">
+		<xsd:annotation>
+			<xsd:documentation>Informationen zu einem Dokument</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ActualOffset" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Der tatsächliche Offset in der  Ergebnisliste.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ActualMaxResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Tatsächliche Maximalanzahl der Ergebnisse, die der Provider auf eine Anfrage zurück gibt. Beispiel: Consumer fordert 1000 Ergebnisse an, Provider liefert aber maximal 100 zurück. In diesem Fall würde hier 100 zurückgegeben. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="TotalResults" type="xsd:unsignedInt">
+				<xsd:annotation>
+					<xsd:documentation>Gesamtzahl der Dokumente unter dem gewählten Filter.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="DokumentInfos" type="cst:DokumentenReferenz_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Die Ergebnisliste</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zeitraum" type="cst:Zeitraum_Type"/>
+		</xsd:sequence>
+	</xsd:complexType>
+</xsd:schema>

client-lib/src/main/resources/def/r1_6_0/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,394 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Mit XMLSpy v2017 rel. 3 sp1 (x64) (http://www.altova.com) von Jens Buehring (Kap Dion GmbH) bearbeitet -->
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ost="urn:omds3ServiceTypes-1-1-0" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.6.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds214-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:omds3ServiceTypes-1-1-0" schemaLocation="omds3ServiceTypes.xsd"/>
+	<!--Prozessobjekte Berechnung, Offert, Antrag - Spartenübergreifend-->
+	<xsd:complexType name="SpezBerechnung_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Berechnung, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffert_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp Offert, der bei Request und Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Offertnummer" type="cst:ObjektId_Type" minOccurs="0"/>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Personen, welche dann über ihre Rolle direkt referenziert werden. Im Offert ist dies insb. der Versicherungsnehmer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntrag_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für Antrag, der bei Request und bei Response gleich ist</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="Antragsart" type="cst:Antragsart_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Die Antragsart kann auch vom ServiceProvider automatisch bestimmt werden, dann bleibt sie im Request leer.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Personen" type="cst:BeteiligtePersonVertrag_Type" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Liste aller benötigten Vertragspersonen (nicht versicherte Personen), welche dann über ihre Rolle referenziert werden. Die Personen können eine Adresse enthalten.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Versicherungsnehmer" type="xsd:unsignedShort">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf die Person, die als Versicherungsnehmer fungiert. </xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbweichenderPraemienzahler" type="xsd:unsignedShort" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf einen abweichenden Praemienzahler, wenn nicht der Verisicherungsnehmer die Prämie zahlt</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVersicherungsnehmer" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Referenz auf weitere Versicherungsnehmer</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="WeitereVertragspersonen" type="cst:Vertragsperson_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Weitere Personen in Vertragsrollen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="AbgelehnteRisiken" type="cst:AbgelehnteRisiken_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Bestehen Ablehnungen zu den beantragten Risiken</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Vorversicherungen" type="cst:Vorversicherungen_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Bestehen Vorversicherungen zu dem Antrag</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Zahlungsdaten" type="cst:Zahlungsdaten_Type">
+				<xsd:annotation>
+					<xsd:documentation>Beschreibt die Art der Zahlung und enthält die zugehörigen Daten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Sepa" type="cst:SepaCd_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>SEPA-Mandat-Steuerung, wenn Zahlungsdaten ein SEPA-Mandat notwendig machen.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Polizzenversand" type="cst:PolizzenversandType" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>alternativer Polizzenversand</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Datenschutzbestimmungen" type="cst:Datenverwendung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Allgemeine Datenschutzbestimmungen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="Kontierung" type="cst:Kontierung_Type" minOccurs="0" maxOccurs="3"/>
+			<xsd:element name="Ersatzpolizzennummer" type="cst:Ersatzpolizzen_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Ersatzpolizzennummern bei Konvertierung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusendungWeitereDokumente" type="xsd:string" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Sollen weitere Antragsdokumente zugestellt werden (z.B. IVK)</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdaten" type="ZusaetzlicheAntragsdaten_Type" minOccurs="0" maxOccurs="unbounded">
+				<xsd:annotation>
+					<xsd:documentation>Moeglichkeit fuer die Erweitung des Standards um eigene Antragsdaten</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!--Abstrakte BOA-Operationstypen-->
+	<xsd:complexType name="CalculateRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="RequestUpselling" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation>Sollen Upselling-Vorschläge mitberechnet werden? Wenn ja kann dies zu einer längeren Berechnungsdauer führen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Ergebnis der Berechnung enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für das Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der das Offert enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Offertdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für den Antrag</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response, der den Antrag enthält bzw. Fehlermeldungen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>optional ein aktueller Status des Antragsprozess</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Wenn der Antrag fehlerfrei erstellt werden konnte, die Referenz auf diesen Antrag. Diese Referenz ist bei der Einreichung des Antrags anzugegeben.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequest_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Dateianhaenge" type="cst:Dateianhang_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Ergänzende Dokumente zum Antrag, z.B. SEPA-Mandat oder Gutachten über den Zustand des Fahrzeugs.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Die Referenz auf einen zuvor mit CreateApplication erzeugten Antrag, welcher jetzt eingereicht werden soll. Diese Referenz wird durch CreateApplication erzeugt. Entweder ist solch ein Bezug zu einem vorangegangenen SubmitApplication mitzugeben oder nochmals die Daten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonProcessResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragstatus" type="cst:SubmitApplicationStatus_Type">
+						<xsd:annotation>
+							<xsd:documentation>aktueller Status des eingespielten Antrages</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Antragsnummer" type="cst:ObjektId_Type"/>
+					<xsd:element name="Dokumente" type="cst:DokumentInfo_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Referenzen auf Antragsdokumente, die heruntergeladen werden können.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Berechnung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response Berechnung </xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CalculateResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request für die Offerterstellung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Offerterstellung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateOfferResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragserzeugung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragserzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="CreateApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationRequestGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Request der Antragsüberleitung mit generischen Produktbausteinen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Produktmetadaten" type="xsd:boolean">
+						<xsd:annotation>
+							<xsd:documentation>Wenn "wahr", sollen im Response Produktmetadaten enthalten sein.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationResponseGen_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Response der Antragsüberleitung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SubmitApplicationResponse_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusaetzlicheAntragsdaten_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ fuer die Erweiterung des Antrags um Elemente, die nicht im Standard enthalten sind</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="DokumentId" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>Eine DokumentenId als String</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Dokument" type="cst:DokumentInfo_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:element name="GetApplicationDocumentRequest" type="GetApplicationDocumentRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zu beziehen</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="GetApplicationDocumentResponse" type="GetApplicationDocumentResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Element um Offert- und Antragsdokumente zurückzugeben</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+</xsd:schema>

client-lib/src/main/resources/def/r1_6_0/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,600 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:omds="urn:omds20" xmlns:cst="urn:omds3CommonServiceTypes-1-1-0" xmlns:ac="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" targetNamespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.kfz" elementFormDefault="qualified" attributeFormDefault="qualified" version="1.6.0">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds214-00.xsd"/>
+	<xsd:import namespace="urn:omds3CommonServiceTypes-1-1-0" schemaLocation="omds3CommonServiceTypes.xsd"/>
+	<xsd:import namespace="urn:at.vvo.omds.types.omds3types.v1-3-0.on2antrag.common" schemaLocation="omds3_ON2_Antrag_Common.xsd"/>
+	<xsd:annotation>
+		<xsd:documentation>Produktmodell Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:complexType name="VerkaufsproduktKfz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produktbündel, welches einem Vertrag entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Verkaufsprodukt_Type">
+				<xsd:sequence>
+					<xsd:element name="Gebdat" type="xsd:date" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Geburtsdatum als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="PLZ" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PLZ als Tarifmerkmal</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:minLength value="1"/>
+								<xsd:maxLength value="7"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:element>
+					<xsd:element name="PersArtCd" type="omds:PersArtCd_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>PersonArtCd als Tarifmerkmal: N = nat. Person, S = sonst. Person</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="KfzVersicherung" type="ProduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="KfzZusatzVersicherung" type="ZusatzproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteFahrzeuge" type="cst:Fahrzeug_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>In Analogie zum OMDS-Datensatz befinden sich die Risikoobjekte als Element in der obersten Produktebene (OMDS Datensatz Element VERTRAG)</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Kfz-Produkt, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type">
+				<xsd:sequence>
+					<xsd:element name="Haftpflicht" type="HaftpflichtKfz_Type"/>
+					<xsd:choice>
+						<xsd:element name="Teilkasko" type="TeilkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+						<xsd:element name="Vollkasko" type="VollkaskoKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:choice>
+					<xsd:element name="Insassenunfall" type="InsassenUnfallKfz_Type" minOccurs="0"/>
+					<xsd:element name="Assistance" type="AssistanceKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ZusatzproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Zusatzprodukte, die mit einer KFZ-Versicherung gebündelt werden können.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Produkt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakte Basisklasse für KFZ-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type">
+				<xsd:sequence>
+					<xsd:element ref="FahrzeugRefLfdNr" minOccurs="0"/>
+					<xsd:element name="LeasingVerbundUnternehmen" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="HaftpflichtKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Haftpflicht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Haftpflicht erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element ref="omds:EL-Versicherungssumme">
+						<xsd:annotation>
+							<xsd:documentation>Versicherungssumme Haftpflicht</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="VarianteLeihwagen" type="VarianteLeihwagen_Type"/>
+					<xsd:element ref="omds:EL-Einstufung"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="VDNummer" type="xsd:string" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="KaskoKfz_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Basistyp für die Kasko-Elementarprodukte</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Art" type="omds:VtgSparteCd_Type">
+						<xsd:annotation>
+							<xsd:documentation>Nur KFZ-Teilkasko bzw. KFZ-Vollkasko erlaubt</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="SelbstbehaltBisBetrag" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="KMLeistung" type="xsd:unsignedInt" minOccurs="0"/>
+					<xsd:element name="VorsteuerAbzugBerechtigung" type="xsd:boolean"/>
+					<xsd:element name="Vinkulierung" type="cst:Vinkulierung_Type" minOccurs="0"/>
+					<xsd:element name="Bezugsrecht" type="cst:Bezugsrecht_Type" minOccurs="0"/>
+					<xsd:element name="Zielpraemie" type="omds:decimal" minOccurs="0"/>
+					<xsd:element name="Eingeschraenkt" type="xsd:boolean" default="0" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="TeilkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Teilkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Vandalismusklausel" type="xsd:boolean"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VollkaskoKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Vollkasko</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="KaskoKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Neuwertklausel" type="xsd:boolean" minOccurs="0"/>
+					<xsd:element name="Leasingklausel" type="xsd:boolean" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="InsassenUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Insassenunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="InsassenUnfallSystem" type="InsassenUnfallSystem_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="LenkerUnfallKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Lenkerunfall</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="AssistanceKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Assistance</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ElementarproduktKfz_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktKfzRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für eine Kfz-Rechtsschutz-Versicherung, welches einer Vertragssparte entspricht</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ZusatzproduktKfz_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkehrsrechtsschutz" type="VerkehrsrechtsschutzKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="VerkehrsrechtsschutzKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für das Elementarprodukt KFZ-Verkehrsrechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Elementarprodukt_Type"/>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!--Typen für die BOA-Services fuer Kfz -->
+	<xsd:complexType name="SpezBerechnungKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Berechnungsanfrage und Berechnungsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Offertanfrage und Offertantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezOffert_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ der das Produkt beschreibt und in Antragsanfrage und Antragsantwort verwendet wird</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SpezAntrag_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="VerkaufsproduktKfz_Type"/>
+					<xsd:element name="BonusMalus" type="cst:BonusMalusSystem_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>BonusMalus beim Verband</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Vinkulierung" type="cst:Vinkularglaeubiger_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Vinkulierungsdaten</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ZusaetzlicheKfzDaten" type="ZusaetzlicheKfzdaten_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="UpsellingKfzResponse_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Response Upselling Alternativen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="UpsellingVerkaufsprodukte" type="VerkaufsproduktKfz_Type" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsanfrage" type="SpezBerechnungKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Kfz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CalculateResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Berechnungsantwort" type="SpezBerechnungKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Berechnung die Details der Berechnung.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="ResponseUpselling" type="UpsellingKfzResponse_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Response für das Upselling, wenn solche Ergebnisse angefordert wurden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Request für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertanfrage" type="SpezOffertKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Response für ein Kfz-Offert</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateOfferResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Offertantwort" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Bei erfolgreicher Erstellung eines Offerts.</xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="SpezOffertKfz_Type"/>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für die Erzeugung eines Kfz-Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:CreateApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Requestobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Antraganfrage" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional die Daten des Antrags, wenn nicht Bezug auf ein vorangegangenes SubmitApplication genommen wird.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ des Responseobjekts für eine Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="ac:SubmitApplicationResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Antragantwort" type="SpezAntragKfz_Type" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Hier werden nochmals alle Antragsdaten zur Verfügung gestellt.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:annotation>
+		<xsd:documentation>Konkrete Services (Request- und Responseobjekte) Kfz</xsd:documentation>
+	</xsd:annotation>
+	<xsd:element name="CalculateKfzRequest" type="CalculateKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Kfz Berechnung</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateKfzResponse" type="CalculateKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Berechnung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzRequest" type="CreateOfferKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für ein Kfz Offert</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateOfferKfzResponse" type="CreateOfferKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Offert Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzRequest" type="CreateApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für einen Kfz Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CreateApplicationKfzResponse" type="CreateApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response Antrag Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzRequest" type="SubmitApplicationKfzRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationKfzResponse" type="SubmitApplicationKfzResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer die Antragseinreichung Kfz</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="FahrzeugRefLfdNr" type="xsd:string">
+		<xsd:annotation>
+			<xsd:documentation>Refernziert auf ein versichertes Fahrzeug über die laufende Nummer innerhalb eines Elementarprodukts.</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:complexType name="VorversicherungenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Vorversicherungen für Kfz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:Vorversicherungen_Type">
+				<xsd:sequence>
+					<xsd:element name="VorversicherungKfz" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="cst:VorversicherungenDetail_Type">
+									<xsd:attribute name="VtgSparteCd" type="omds:VtgSparteCd_Type" use="optional"/>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="VorversicherungRechtsschutz" type="cst:VorversicherungenDetail_Type" minOccurs="0"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:simpleType name="InsassenUnfallSystem_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type System Insassenunfallversicherung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Pauschalsystem"/>
+			<xsd:enumeration value="Platzsystem1"/>
+			<xsd:enumeration value="Platzsystem2"/>
+			<xsd:enumeration value="Personensystem"/>
+			<xsd:enumeration value="Lenkerunfallversicherung"/>
+			<xsd:enumeration value="Aufsassenunfallversicherung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="VarianteLeihwagen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Variante Leihwagen (A, B)</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="VA">
+				<xsd:annotation>
+					<xsd:documentation>ohne Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="VB">
+				<xsd:annotation>
+					<xsd:documentation>mit Leihwagen</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Zusätzliche KFZ-Daten -->
+	<xsd:complexType name="ZusaetzlicheKfzdaten_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type zusätzliche Kfz-Daten</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="KfzKennzeichen">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:minLength value="3"/>
+						<xsd:maxLength value="9"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="Fahrgestellnummer" type="Fahrgestellnummer_Type"/>
+			<xsd:element name="ErfolgtAnmeldungZeitgleichMitAbmeldung" type="xsd:boolean" minOccurs="0"/>
+			<xsd:element name="AbmeldedatumWechselkennzeichenFahrzeug" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="Wechselkennzeichen" type="Wechselkennzeichen_Type" minOccurs="0"/>
+			<xsd:element name="Fahrzeugzustand" type="xsd:string" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Fahrzeugzustand als Schlüsselwerte</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="FzZustandBesichtigung" type="FzZustandBesichtigung_Type" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Detailierte Fahrzeugzustandsbeschreibung z.B. aus einer Besichtigung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ZusaetzlicheAntragsdatenKfz" type="ZusaetzlicheAntragsdatenKfz_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:complexType name="Wechselkennzeichen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Wechselkennzeichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="WechselkennzeichenArt">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="Neues Fahrzeug als WKZ in bestehenden Vertrag einbündeln"/>
+						<xsd:enumeration value="Fahrzeugwechsel im bestehenden WKZ-Vertrag"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:element>
+			<xsd:element name="BestehenderWechselkennzeichenvertrag" type="xsd:string"/>
+			<xsd:element name="ErsetztWirdFahrgestellnummer" type="Fahrgestellnummer_Type" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="Fahrgestellnummer_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Fahrgestellnummer FIN</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:minLength value="1"/>
+			<xsd:maxLength value="30"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="FzZustandBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Ergebnisse einer Besichtigung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="ZustandsberichtLiegtAlsFormularBei" type="xsd:boolean" minOccurs="0">
+				<xsd:annotation>
+					<xsd:documentation>Zustandsbericht liegt als Formular bei bzw. Besichtigung durch externe Stelle veranlasst - muss dann als Attachment mitgeschickt werden.</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="ArtBesichtigung" type="ArtBesichtigung_Type">
+				<xsd:annotation>
+					<xsd:documentation>Die Art der Besichtigung bzw. Quelle der Zustandsbeschreibung</xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="SchaedenAnScheibenKleinglas" type="SchaedenAnScheibenKleinglas_Type" minOccurs="0"/>
+			<xsd:element name="SchaedenAmFahrzeug" type="SchaedenAmFahrzeug_Type" minOccurs="0"/>
+			<xsd:element name="KilometerLtBesichtigung" type="xsd:integer" minOccurs="0"/>
+			<xsd:element name="Vorschaeden" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsort" type="xsd:string" minOccurs="0"/>
+			<xsd:element name="Besichtigungsdatum" type="xsd:date" minOccurs="0"/>
+			<xsd:element name="GrundFuerNachbesichtigung" type="xsd:string" minOccurs="0"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<xsd:simpleType name="ArtBesichtigung_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Zustandsbeschreibung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="Besichtigung durch Betreuer"/>
+			<xsd:enumeration value="Kaufvertrag Markenhaendler mit Beschreibung"/>
+			<xsd:enumeration value="Besichtigung durch ARBOE, OEAMTC"/>
+			<xsd:enumeration value="Nachbesichtigung"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAnScheibenKleinglas_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Beschreibung Schäden an Kleinglas</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an Scheiben / Kleinglas"/>
+			<xsd:enumeration value="Schäden an Scheiben / Kleinglas"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:simpleType name="SchaedenAmFahrzeug_Type">
+		<xsd:annotation>
+			<xsd:documentation>Type Schäden am Fahrzeug</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="keine Schäden an der Karosserie"/>
+			<xsd:enumeration value="Schäden an der Karosserie"/>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<xsd:complexType name="ZusaetzlicheAntragsdatenKfz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ für VU-Spezifische Erweiterungen bei der Kfz-Beschreibung im Antrag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:complexType>
+</xsd:schema>