Projektstruktur vereinfacht

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;
+    }
+
+}

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());
+
+    }
+}

src/main/java/at/vvo/omds/client/api/CommonRequest.java

@@ -0,0 +1,7 @@
+package at.vvo.omds.client.api;
+
+public interface CommonRequest {
+
+    /// Liefert die KorrelationsId eines Requests
+    String getKorrelationsId();
+}

src/main/java/at/vvo/omds/client/api/Product.java

@@ -0,0 +1,61 @@
+package at.vvo.omds.client.api;
+
+import java.time.LocalDate;
+
+
+public class Product {
+
+    String vu;
+    String name;
+    long  id;
+    LocalDate from;
+    LocalDate to;
+
+    public String getVu() {
+        return vu;
+    }
+
+    public void setVu(String vu) {
+        this.vu = vu;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public LocalDate getFrom() {
+        return from;
+    }
+
+    public void setFrom(LocalDate from) {
+        this.from = from;
+    }
+
+    public LocalDate getTo() {
+        return to;
+    }
+
+    public void setTo(LocalDate to) {
+        this.to = to;
+    }
+
+    public Product(String vu, String name, long id, LocalDate from, LocalDate to) {
+        this.vu = vu;
+        this.name = name;
+        this.id = id;
+        this.from = from;
+        this.to = to;
+    }
+}

src/main/java/at/vvo/omds/client/api/ProduktbausteinInterface.java

@@ -0,0 +1,24 @@
+package at.vvo.omds.client.api;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+public interface ProduktbausteinInterface {
+    String getId();
+    void setId(String id);
+
+    String getName();
+    void setName(String name);
+
+    XMLGregorianCalendar getFrom();
+    void setFrom(XMLGregorianCalendar from);
+
+    XMLGregorianCalendar getTo();
+    void setTo(XMLGregorianCalendar to);
+
+    int getMinOccurrences();
+    void setMinOccurrences(int minOccurrences);
+
+    Integer getMaxOccurrences();
+    void setMaxOccurrences(Integer maxOccurrences);
+
+}

src/main/java/at/vvo/omds/client/api/SOAPConnector.java

@@ -0,0 +1,145 @@
+package at.vvo.omds.client.api;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.CalculateUnfallRequestType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.CalculateUnfallResponseType;
+import jakarta.xml.bind.*;
+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.parsers.ParserConfigurationException;
+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 CalculateUnfallResponseType callCalcUnfall(String url, JAXBElement<CalculateUnfallRequestType> request, String token) throws Exception {
+
+        logger.info("Url:" + url);
+        logger.info("Request VUNr:" + request.getValue().getVUNr());
+
+        SOAPConnectionFactory connectionFactory = SOAPConnectionFactory.newInstance();
+        SOAPConnection soapConnection = connectionFactory.createConnection();
+
+        //Weil es noch keine Klasse für Zusätzlicheverkaufsprodukte 2025 gibt
+        request.getValue().getBerechnungsanfrage().getVerkaufsprodukt().getZusaetzlicheVerkaufproduktdaten().clear();
+
+        SOAPMessage req = createRequest(request, token);
+
+
+//        printMessage(req);
+
+        SOAPMessage response = soapConnection.call(req, url);
+
+
+        JAXBContext jaxbContext = JAXBContext.newInstance("at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall");
+        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();;
+
+        JAXBElement<CalculateUnfallResponseType> erg =
+                (JAXBElement<CalculateUnfallResponseType>) unmarshaller.unmarshal(response.getSOAPBody().extractContentAsDocument());
+        soapConnection.close();
+
+       return erg.getValue();
+    }
+
+    private SOAPMessage createRequest(JAXBElement<CalculateUnfallRequestType> 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<CalculateUnfallRequestType> request, String token) throws Exception {
+        SOAPPart soapPart = soapMessage.getSOAPPart();
+
+        String namespace = "CalculateUnfallRequestType";
+        String namespaceUrl = "at.vvo.omds.types.omds3types.v1-4-0.on2antrag.unfall";
+
+        SOAPEnvelope envelope = soapPart.getEnvelope();
+//        envelope.addNamespaceDeclaration(namespace, namespaceUrl);
+        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()));
+
+        JAXBContext jaxbContext = JAXBContext.newInstance("at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall");
+
+        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");
+        }
+    }
+}

src/main/java/at/vvo/omds/client/api/UnfallCalcService.java

@@ -0,0 +1,39 @@
+package at.vvo.omds.client.api;
+
+import at.vvo.omds.client.api.unfall.BuildUnfallRequest;
+import at.vvo.omds.client.api.unfall.VerkaufsproduktUnfall;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.CalculateUnfallRequestType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.CalculateUnfallResponseType;
+import jakarta.xml.bind.JAXBElement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class UnfallCalcService {
+
+    Logger log = LoggerFactory.getLogger(UnfallCalcService.class);
+
+    private final SOAPConnector soapConnector;
+
+    public UnfallCalcService(SOAPConnector soapConnector) {
+        this.soapConnector = soapConnector;
+    }
+
+    public VerkaufsproduktUnfall calc(VerkaufsproduktUnfall verkaufsproduktUnfall) throws Exception {
+
+        String vuNr = "043";
+        String token = "<KEY>";
+        JAXBElement<CalculateUnfallRequestType> r = BuildUnfallRequest.unfall(vuNr, verkaufsproduktUnfall);
+        CalculateUnfallResponseType response =
+                soapConnector.callCalcUnfall(
+                        "http://localhost:9090/ws", r, token
+                );
+        log.info("Got Response As below ========= : ");
+        log.info("Status : {}", response.getStatus().getErgebnis().value());
+
+        response.getBerechnungsantwort().getVerkaufsprodukt().getPraemie().stream().findFirst()
+        .ifPresent(praemieType -> verkaufsproduktUnfall.setPraemie(praemieType.getPraemieBto()));
+
+        return verkaufsproduktUnfall;
+    }
+}

src/main/java/at/vvo/omds/client/api/UnterbausteinInterface.java

@@ -0,0 +1,5 @@
+package at.vvo.omds.client.api;
+
+public interface UnterbausteinInterface extends ProduktbausteinInterface {
+
+}

src/main/java/at/vvo/omds/client/api/VerkaufsproduktInterface.java

@@ -0,0 +1,11 @@
+package at.vvo.omds.client.api;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+/// Ein Verkaufsprodukt muss a priori liefern können, ab wann es verkauft werden darf.
+public interface VerkaufsproduktInterface extends ProduktbausteinInterface {
+
+//    XMLGregorianCalendar getVtgbeg();
+//
+//    void setVtgbeg(XMLGregorianCalendar value);
+}

src/main/java/at/vvo/omds/client/api/unfall/BuildUnfallRequest.java

@@ -0,0 +1,113 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds2.v2_17.ELRahmenvereinbarungType;
+import at.vvo.omds.types.omds3.r2025_05.common.BeteiligtePersonVertragType;
+import at.vvo.omds.types.omds3.r2025_05.common.VersichertePersonType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.CalculateUnfallRequestType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.ProduktUnfallType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.SpezBerechnungUnfallType;
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.VerkaufsproduktUnfallType;
+import at.vvo.omds.client.BuildRequestHelper;
+import jakarta.xml.bind.JAXBElement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BuildUnfallRequest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BuildUnfallRequest.class);
+
+    private static final at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.ObjectFactory OUOF =
+            new at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.ObjectFactory();
+
+    public static final String UNFALLVORSORGE = "unfallvorsorge";
+
+    /** Privater default Constructor versteckt den nicht benötigten Default-Constructor. */
+    private BuildUnfallRequest() {
+    }
+
+    static public JAXBElement<CalculateUnfallRequestType> unfall(String vuNr, VerkaufsproduktUnfall vkp) {
+        LOG.info("VUNr = " + vuNr);
+
+        CalculateUnfallRequestType request = OUOF.createCalculateUnfallRequestType();
+        request.setVUNr(vuNr);
+        request.setRequestUpselling(false);
+        request.setProduktmetadaten(false);
+        request.setClientId("OMDS_TEST");
+        request.setKorrelationsId("123456");
+        request.setAenderungsgrund("NEU");
+        request.setBerechnungsanfrage(createSpezBerechnungUnfall(vkp));
+        return OUOF.createCalculateUnfallRequest(request);
+    }
+
+
+    private static SpezBerechnungUnfallType createSpezBerechnungUnfall(VerkaufsproduktUnfall vkp) {
+        SpezBerechnungUnfallType berechnung = OUOF.createSpezBerechnungUnfallType();
+
+        // setze Daten der versicherten Personen in das Berechnungsobjekt
+        for (VersichertePerson vp : vkp.getVersichertePersonen()) {
+            int lfnr = berechnung.getPersonen().size() + 1;
+
+            // lege Person an
+            BeteiligtePersonVertragType beteiligtePerson = new BeteiligtePersonVertragType();
+
+            beteiligtePerson.setLfnr(lfnr);
+            beteiligtePerson.setPerson(vp.getPerson());
+            berechnung.getPersonen().add(beteiligtePerson);
+            vp.setLfnr(lfnr);
+
+        }
+        // Configuriere
+        berechnung.setVerkaufsprodukt(createVerkaufsprodukt(vkp));
+        return berechnung;
+    }
+
+    private static VerkaufsproduktUnfallType createVerkaufsprodukt(VerkaufsproduktUnfall vkp) {
+        VerkaufsproduktUnfallType omdsVerkaufsproduktUnfall = OUOF.createVerkaufsproduktUnfallType();
+        omdsVerkaufsproduktUnfall.setId(UNFALLVORSORGE);
+        omdsVerkaufsproduktUnfall.setVtgBeg(BuildRequestHelper.zuXml(vkp.getVertragsbeginn()));
+        omdsVerkaufsproduktUnfall.setZahlrhythmus(String.valueOf(vkp.getZahlrhythmus()));
+        omdsVerkaufsproduktUnfall.setHauptfaelligkeit(BuildRequestHelper.hauptfalligkeit(vkp.getMonatHauptfaelligkeit()));
+        omdsVerkaufsproduktUnfall.setVermittlernr(vkp.getVermittlerNr());
+        omdsVerkaufsproduktUnfall.setELRahmenvereinbarung(createRahmenvereinbarung(vkp.getRahmenvertragsnummer())); // ist doppelt, siehe ZusaetzlicheVerkaufsproduktdaten
+//        omdsVerkaufsproduktUnfall.getZusaetzlicheVerkaufproduktdaten().add(createZusaetzlicheVerkaufsproduktdaten(vkp));
+        omdsVerkaufsproduktUnfall.setEingeschlossen(true);
+
+
+
+        // lege Produkt an
+        for (VersichertePerson vp : vkp.getVersichertePersonen()) {
+
+            // lege Risikoinformation zur versicherten Person an
+            VersichertePersonType versichertePersonType = new VersichertePersonType();
+            versichertePersonType.setLfnr(vp.getLfnr());
+            omdsVerkaufsproduktUnfall.getVersichertePersonen().add(versichertePersonType);
+
+            // lege Produkt zur versicherten Person an
+            omdsVerkaufsproduktUnfall.getUnfallprodukte().add(legeVersichertePersonAn(vp));
+        }
+        return omdsVerkaufsproduktUnfall;
+    }
+
+    private static ProduktUnfallType legeVersichertePersonAn(VersichertePerson vp) {
+        ProduktUnfallType p = OUOF.createProduktUnfallType();
+
+        p.setEingeschlossen(true);
+        p.setVersPersonenRefLfnr(vp.getLfnr());
+
+        // lege Leistungsarten an
+        for (Leistungsart l : vp.getLeistungsarten()) {
+            p.getLeistungsarten().add(l.produceRequestObject());
+        }
+
+        return p;
+    }
+
+
+    private static ELRahmenvereinbarungType createRahmenvereinbarung(String nr) {
+        ELRahmenvereinbarungType r = new ELRahmenvereinbarungType();
+        r.setRahmenVebnr(nr);
+        return r;
+    }
+
+
+}

src/main/java/at/vvo/omds/client/api/unfall/DefaultUnfallBuilder.java

@@ -0,0 +1,32 @@
+package at.vvo.omds.client.api.unfall;
+
+import java.time.LocalDate;
+import java.time.Month;
+import java.util.Calendar;
+
+public class DefaultUnfallBuilder {
+
+    public static VerkaufsproduktUnfall createDefault() {
+
+        return new VerkaufsproduktUnfall(
+                LocalDate.now().plusDays(3),
+                2,
+                Calendar.AUGUST,
+                "6342342346",
+                10,
+                false
+        ).setRahmenvertrag("243234234", 0)
+                .add(new VersichertePerson(
+                                "Ansgar", "Meyer", LocalDate.of(1955, Month.FEBRUARY, 20),
+                                "Schüttelstraße", "77", 1020, "Wien",
+                                "Angestellter", null
+                        )
+                                .add(new LeistungsartUnfalltod(10000))
+                                .add(new LeistungsartInvaliditaet(100000))
+                                .add(new LeistungsartUnfallrente(1900))
+                                .add(new LeistungsartSpitalgeld(20))
+                                .add(new LeistungsartUnfallkosten(1250))
+                                .add(new LaUnfallAssistance())
+                );
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/LaUnfallAssistance.java

@@ -0,0 +1,19 @@
+package at.vvo.omds.client.api.unfall;
+
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+public class LaUnfallAssistance extends Leistungsart {
+
+
+    public LaUnfallAssistance() {
+        super();
+    }
+
+    @Override
+    public LeistungsartUnfallType produceRequestObject() {
+        LeistungsartUnfallType la = OUOF.createLeistungsartUnfallType();
+        la.setEingeschlossen(true);
+        return la;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/Leistungsart.java

@@ -0,0 +1,31 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+import java.math.BigDecimal;
+
+public abstract class Leistungsart {
+
+    protected static final at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.ObjectFactory OUOF =
+            new at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.ObjectFactory();
+
+    private BigDecimal versicherungssumme;
+
+    public Leistungsart() {
+    }
+
+    protected Leistungsart(int versicherungssumme) {
+        // etwas spezielle Art eine 2-stelligen Betrag zu erzeugen
+        this.versicherungssumme = new BigDecimal(versicherungssumme + ".00");
+    }
+
+    public BigDecimal getVersicherungssumme() {
+        return versicherungssumme;
+    }
+
+    public void setVersicherungssumme(BigDecimal versicherungssumme) {
+        this.versicherungssumme = versicherungssumme;
+    }
+
+    abstract public LeistungsartUnfallType produceRequestObject();
+}

src/main/java/at/vvo/omds/client/api/unfall/LeistungsartInvaliditaet.java

@@ -0,0 +1,21 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+public class LeistungsartInvaliditaet extends Leistungsart {
+
+    public LeistungsartInvaliditaet(
+            Integer vs
+    ) {
+        super( vs);
+
+    }
+
+    @Override
+    public LeistungsartUnfallType produceRequestObject() {
+        LeistungsartUnfallType la = OUOF.createLeistungsartUnfallType();
+        la.setEingeschlossen(true);
+        la.setVersicherungssumme(getVersicherungssumme());
+        return la;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/LeistungsartSpitalgeld.java

@@ -0,0 +1,19 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+public class LeistungsartSpitalgeld extends Leistungsart {
+
+
+    public LeistungsartSpitalgeld(Integer vs) {
+        super(vs);
+    }
+
+    @Override
+    public LeistungsartUnfallType produceRequestObject() {
+        LeistungsartUnfallType la = OUOF.createLeistungsartUnfallType();
+        la.setEingeschlossen(true);
+        la.setVersicherungssumme(getVersicherungssumme());
+        return la;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/LeistungsartUnfallkosten.java

@@ -0,0 +1,18 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+public class LeistungsartUnfallkosten extends Leistungsart {
+
+    public LeistungsartUnfallkosten(Integer vs) {
+        super(vs);
+    }
+
+    @Override
+    public LeistungsartUnfallType produceRequestObject() {
+        LeistungsartUnfallType la = OUOF.createLeistungsartUnfallType();
+        la.setEingeschlossen(true);
+        la.setVersicherungssumme(getVersicherungssumme());
+        return la;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/LeistungsartUnfallrente.java

@@ -0,0 +1,18 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+public class LeistungsartUnfallrente extends Leistungsart {
+
+    public LeistungsartUnfallrente(Integer vs) {
+        super(vs);
+    }
+
+    @Override
+    public LeistungsartUnfallType produceRequestObject() {
+        LeistungsartUnfallType la = OUOF.createLeistungsartUnfallType();
+        la.setEingeschlossen(true);
+        la.setVersicherungssumme(getVersicherungssumme());
+        return la;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/LeistungsartUnfalltod.java

@@ -0,0 +1,17 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall.LeistungsartUnfallType;
+
+public class LeistungsartUnfalltod extends Leistungsart {
+    public LeistungsartUnfalltod(Integer vs) {
+        super(vs);
+    }
+
+    @Override
+    public LeistungsartUnfallType produceRequestObject() {
+        LeistungsartUnfallType la = OUOF.createLeistungsartUnfallType();
+        la.setEingeschlossen(true);
+        la.setVersicherungssumme(getVersicherungssumme());
+        return la;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/VerkaufsproduktUnfall.java

@@ -0,0 +1,165 @@
+package at.vvo.omds.client.api.unfall;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class VerkaufsproduktUnfall {
+
+    private LocalDate vertragsbeginn;
+    private int zahlrhythmus;
+    private int monatHauptfaelligkeit;
+    private String vermittlerNr;
+    private String rahmenvertragsnummer;
+    private Integer rahmenvertragsRabatt;
+    private int dauerInJahren;
+    private boolean indexanpassung;
+    private BigDecimal praemie;
+
+    // Unterelemente
+    private List<VersichertePerson> versichertePersonen = new ArrayList<>();
+
+    /**
+     * Fügt eine versicherte Person zum Verkaufsprodukt hinzu.
+     * Versicherte Person ist die Kombination aus Partnerdaten, Risikodaten der Person, und
+     * Deckung (Unfallprodukt).
+     * @param vp die versicherte Person
+     * @return dieses Verkaufsprodukt
+     */
+    public VerkaufsproduktUnfall add(VersichertePerson vp) {
+        versichertePersonen.add(vp);
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder b = new StringBuilder();
+        b.append(
+        "VerkaufsproduktUnfall\n" +
+        "   ├─ Vertragsbeginn = " + vertragsbeginn + "\n" +
+        "   ├─ Zahlrhythmus = " + zahlrhythmus + "\n" +
+        "   ├─ Monat Hauptfaelligkeit = " + monatHauptfaelligkeit + "\n" +
+        "   ├─ Vermittlernummer = '" + vermittlerNr + '\'' + "\n" +
+        "   ├─ Rahmenvertragsnummer = '" + rahmenvertragsnummer + '\'' + "\n" +
+        "   ├─ RahmenvertragsRabatt = " + rahmenvertragsRabatt + "\n" +
+        "   ├─ Dauer In Jahren = " + dauerInJahren + "\n" +
+        "   ├─ Indexanpassung = " + indexanpassung + "\n");
+
+        if(praemie !=null)
+            b.append(
+            "   ├─ PRAEMIE Bto = ( " + praemie + " EUR )\n");
+
+        b.append(
+        "   └─ Versicherte Personen \n" +
+        "         │\n");
+        versichertePersonen.forEach(b::append);
+        return b.toString();
+    }
+
+    public VerkaufsproduktUnfall setRahmenvertrag(String number, int prozentRabatt) {
+        this.rahmenvertragsnummer = number;
+        this.rahmenvertragsRabatt = prozentRabatt;
+        return this;
+    }
+
+    public LocalDate getVertragsbeginn() {
+        return vertragsbeginn;
+    }
+
+    public void setVertragsbeginn(LocalDate vertragsbeginn) {
+        this.vertragsbeginn = vertragsbeginn;
+    }
+
+    public int getZahlrhythmus() {
+        return zahlrhythmus;
+    }
+
+    public void setZahlrhythmus(int zahlrhythmus) {
+        this.zahlrhythmus = zahlrhythmus;
+    }
+
+    public int getMonatHauptfaelligkeit() {
+        return monatHauptfaelligkeit;
+    }
+
+    public void setMonatHauptfaelligkeit(int monatHauptfaelligkeit) {
+        this.monatHauptfaelligkeit = monatHauptfaelligkeit;
+    }
+
+    public String getVermittlerNr() {
+        return vermittlerNr;
+    }
+
+    public void setVermittlerNr(String vermittlerNr) {
+        this.vermittlerNr = vermittlerNr;
+    }
+
+    public String getRahmenvertragsnummer() {
+        return rahmenvertragsnummer;
+    }
+
+    public void setRahmenvertragsnummer(String rahmenvertragsnummer) {
+        this.rahmenvertragsnummer = rahmenvertragsnummer;
+    }
+
+    public Integer getRahmenvertragsRabatt() {
+        return rahmenvertragsRabatt;
+    }
+
+    public void setRahmenvertragsRabatt(Integer rahmenvertragsRabatt) {
+        this.rahmenvertragsRabatt = rahmenvertragsRabatt;
+    }
+
+    public int getDauerInJahren() {
+        return dauerInJahren;
+    }
+
+    public void setDauerInJahren(int dauerInJahren) {
+        this.dauerInJahren = dauerInJahren;
+    }
+
+    public boolean isIndexanpassung() {
+        return indexanpassung;
+    }
+
+    public void setIndexanpassung(boolean indexanpassung) {
+        this.indexanpassung = indexanpassung;
+    }
+
+    public BigDecimal getPraemie() {
+        return praemie;
+    }
+
+    public void setPraemie(BigDecimal praemie) {
+        this.praemie = praemie;
+    }
+
+    public List<VersichertePerson> getVersichertePersonen() {
+        return versichertePersonen;
+    }
+
+    public void setVersichertePersonen(List<VersichertePerson> versichertePersonen) {
+        this.versichertePersonen = versichertePersonen;
+    }
+
+    public VerkaufsproduktUnfall(
+            LocalDate vertragsbeginn,
+            int zahlrhythmus,
+            int monatHauptfaelligkeit,
+            String vermittlerNr,
+            int dauerInJahren,
+            boolean indexanpassung
+    ) {
+        this.vertragsbeginn = vertragsbeginn;
+        this.zahlrhythmus = zahlrhythmus;
+        this.monatHauptfaelligkeit = monatHauptfaelligkeit;
+        this.vermittlerNr = vermittlerNr;
+        this.rahmenvertragsnummer = rahmenvertragsnummer;
+        this.rahmenvertragsRabatt = rahmenvertragsRabatt;
+        this.dauerInJahren = dauerInJahren;
+        this.indexanpassung = indexanpassung;
+        this.praemie = praemie;
+        this.versichertePersonen = versichertePersonen;
+    }
+}

src/main/java/at/vvo/omds/client/api/unfall/VersichertePerson.java

@@ -0,0 +1,98 @@
+package at.vvo.omds.client.api.unfall;
+
+import at.vvo.omds.types.omds3.r2025_05.common.PersonType;
+import at.vvo.omds.client.BuildRequestHelper;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class VersichertePerson {
+
+    private PersonType person;
+    private String hauptberuf;
+    private String nebenberuf;
+
+    private List<Leistungsart> leistungsarten = new ArrayList<>();
+
+    private Integer lfnr;
+
+    public VersichertePerson(
+        String vorname,
+        String nachname,
+        LocalDate gebDat,
+        String adresse,
+        String hausnummer,
+        int plz,
+        String ort,
+        String hauptberuf,
+        String nebenberuf
+    ) {
+        this.person = BuildRequestHelper.createNatPerson(vorname, nachname, gebDat, adresse, hausnummer, plz, ort);
+        this.hauptberuf = hauptberuf;
+        this.nebenberuf = nebenberuf;
+    }
+
+    public PersonType getPerson() {
+        return person;
+    }
+
+    public void setPerson(PersonType person) {
+        this.person = person;
+    }
+
+    public String getHauptberuf() {
+        return hauptberuf;
+    }
+
+    public void setHauptberuf(String hauptberuf) {
+        this.hauptberuf = hauptberuf;
+    }
+
+    public String getNebenberuf() {
+        return nebenberuf;
+    }
+
+    public void setNebenberuf(String nebenberuf) {
+        this.nebenberuf = nebenberuf;
+    }
+
+    public List<Leistungsart> getLeistungsarten() {
+        return leistungsarten;
+    }
+
+    public void setLeistungsarten(List<Leistungsart> leistungsarten) {
+        this.leistungsarten = leistungsarten;
+    }
+
+    public Integer getLfnr() {
+        return lfnr;
+    }
+
+    public void setLfnr(Integer lfnr) {
+        this.lfnr = lfnr;
+    }
+
+    /**
+     * Fügt eine Leistungsart zur versicherten Person hinzu.
+     * @param leistungsart die Leistungsart
+     * @return diese versicherte Person
+     */
+    public VersichertePerson add(Leistungsart leistungsart) {
+        leistungsarten.add(leistungsart);
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder b = new StringBuilder();
+        b.append(
+        "       VersichertePerson \n" +
+        "         ├─ Person=" + person + "\n" +
+        "         ├─ Hauptberuf='" + hauptberuf + '\'' + "\n" +
+        "         ├─ Lfnr=" + lfnr + "\n" +
+        "         └─ Leistungsarten \n" +
+        "              │\n");
+        return b.toString();
+    }
+}

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

src/main/java/at/vvo/omds/client/gui/GuiProdukt.java

@@ -0,0 +1,32 @@
+package at.vvo.omds.client.gui;
+
+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;
+    }
+}

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

@@ -0,0 +1,426 @@
+package at.vvo.omds.client.gui;
+
+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;
+    }
+
+}

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

@@ -0,0 +1,710 @@
+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.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;
+        }
+    }
+}

src/main/java/at/vvo/omds/client/gui/ObjectFactoryFactory.java

@@ -0,0 +1,38 @@
+package at.vvo.omds.client.gui;
+
+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;
+    }
+}

src/main/java/at/vvo/omds/client/gui/Plausi.java

@@ -0,0 +1,44 @@
+package at.vvo.omds.client.gui;
+
+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; }
+}

src/main/java/at/vvo/omds/client/gui/RDFHelper.java

@@ -0,0 +1,661 @@
+package at.vvo.omds.client.gui;
+
+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.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.eclipse.rdf4j.model.*;
+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.Console;
+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);
+        }
+    }
+}

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;
+    }
+}

src/main/java/at/vvo/omds/client/gui/TreeHelper.java

@@ -0,0 +1,202 @@
+package at.vvo.omds.client.gui;
+
+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.*;
+
+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;
+    }
+}

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");
+        }
+    }
+}

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.client.gui.Plausi;
+import at.vvo.omds.client.gui.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;
+    }
+}

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 at.vvo.omds.types.omds3.r2025_05.common.ObjectFactory OUOF =
+            new at.vvo.omds.types.omds3.r2025_05.common.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);
+    }
+}

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.client.gui.GuiProdukt;
+import at.vvo.omds.client.gui.ObjectFactoryFactory;
+import at.vvo.omds.client.gui.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;
+    }
+}

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.client.gui.GuiProdukt;
+import at.vvo.omds.client.gui.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;
+    }
+}

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>

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>

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>

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>

src/main/resources/def/r2025_27/binding.xjb

@@ -0,0 +1,837 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<bindings xmlns="https://jakarta.ee/xml/ns/jaxb"
+          xmlns:jaxb="https://jakarta.ee/xml/ns/jaxb"
+          xmlns:xs="http://www.w3.org/2001/XMLSchema"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xmlns:annox="urn:jaxb.jvnet.org:annox"
+          xmlns:inheritance="urn:jaxb.jvnet.org:plugin:inheritance"
+          xsi:schemaLocation="https://jakarta.ee/xml/ns/jaxb https://jakarta.ee/xml/ns/jaxb/bindingschema_3_0.xsd"
+          xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"
+          version="3.0">
+          jaxb:extensionBindingPrefixes="xjc annox"
+
+
+
+   <!-- OMDS 2 -->
+   <jaxb:bindings schemaLocation="omds217-00.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds2.v2_17"/>
+      </jaxb:schemaBindings>
+
+      <!-- Raise theEnumMemberSizeCap limit -->
+      <jaxb:bindings>
+         <jaxb:globalBindings typesafeEnumMaxMembers="2000"/>
+      </jaxb:bindings>
+   </jaxb:bindings>
+
+   <!-- Namespace http://omds.vvo.at/types/omds3types/v1_4_0/common  -->
+   <jaxb:bindings schemaLocation="omds3CommonServiceTypes.xsd" node="/xs:schema">
+
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.common"/>
+      </jaxb:schemaBindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='Kombinationen_Type']//xs:element[@name='Kombination']">
+         <jaxb:property name="kombinationen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der zulässigen Kombinationen.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='Kombination_Type']//xs:element[@name='TarifId']">
+         <jaxb:property name="tarifids">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der zulässigen Baustein-Ids.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='KonvertierungsumfangVertrag_Type']//xs:element[@name='Baustein']">
+         <jaxb:property name="bausteine">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Bausteine, die in der Konvertierungsanforderung behandelt werden.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='KonvertierungBaustein_Type']//xs:element[@name='ZulaessigeAktion']">
+         <jaxb:property name="zulaessigeAktionen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Aktionen, die für einen Vertragsbaustein zulässig sind.
+         Die zulässigen Aktionen müssen nur im Response vom ServiceProvider (VU) befüllt werden.
+         Im Request eines Konvertierungsvorschlags durch den Consumer, können sie leer bleiben. </p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='KonvertierungsaktionUebernehmen_Type']//xs:element[@name='Baustein']">
+         <jaxb:property name="bausteine">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Bausteine, die in der Konvertierungsaktion behandelt werden.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <!-- Arrays in Envelope_Type -->
+      <jaxb:bindings node="//xs:complexType[@name='Envelope_Type']//xs:element[@name='Dokument']">
+         <jaxb:property name="Dokumente">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Dokumente im Umschlag.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='Envelope_Type']//xs:element[@name='ObjektSpezifikation']">
+         <jaxb:property name="ObjektSpezifikationen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Objektspezifikationen des Umschlags.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+
+      <!-- Metadaten Dokumente VertragsZuordnung -->
+      <jaxb:bindings node="//xs:complexType[@name='VertragsZuordnung_Type']//xs:element[@name='Vertragsperson']">
+         <jaxb:property name="Vertragspersonen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Personen dieses Vertragsdokuments.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <!-- Metadaten Dokumente SchadenZuordnung -->
+      <jaxb:bindings node="//xs:complexType[@name='SchadenZuordnung_Type']//xs:element[@name='SpartenCd']">
+         <jaxb:property name="Spartencodes">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der betroffenen Sparten dieses Schadendokuments.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='SchadenZuordnung_Type']//xs:element[@name='BeteiligtePerson']">
+         <jaxb:property name="BeteiligtePersonen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der beteiligten Personen dieses Schadendokuments.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='Teildokument_Type']//xs:element[@name='ObjektSpezifikation']">
+         <jaxb:property name="ObjektSpezifikationen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Objektspezifikationen für dieses Teildokument.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <bindings node="xs:complexType[@name='ServiceFault']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="serviceFault"/>
+         </annox:annotate>
+      </bindings>
+
+
+      <jaxb:bindings node="//xs:complexType[@name='BasisProduktbaustein_Type']//xs:element[@name='Attribut']">
+         <jaxb:property name="Attribute">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Attribute für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='BasisProduktbaustein_Type']//xs:element[@name='Meldungen']">
+         <jaxb:property name="Meldungen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Meldungen für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='Produktbaustein_Type']//xs:element[@name='Baustein']">
+         <jaxb:property name="Bausteine">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Unterbausteine für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='APrioriProduktbaustein_Type']//xs:element[@name='Klausel']">
+         <jaxb:property name="Klauseln">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Klauseln für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='APrioriProduktbaustein_Type']//xs:element[@name='Baustein']">
+         <jaxb:property name="Bausteine">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Unterbausteine für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='APrioriProduktbaustein_Type']//xs:element[@name='Attribut']">
+         <jaxb:property name="Attribute">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Attribute für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='APrioriProduktbaustein_Type']//xs:element[@name='Meldung']">
+         <jaxb:property name="Meldungen">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Meldungen für diesen Deckungsbaustein.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+   </jaxb:bindings><!-- Ende omds3CommonServiceTypes -->
+
+   <!-- "Quick-wins" Namespace http://omds.vvo.at/types/omds3types/v1_4_0/servicetypes -->
+   <jaxb:bindings schemaLocation="omds3ServiceTypes.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.servicetypes"/>
+      </jaxb:schemaBindings>
+
+      <bindings node="xs:complexType[@name='LoginRequestType']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="loginRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkBusinessObjectResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="loginResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='UserDataRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getUserDataRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='UserDataResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getUserDataResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='OMDSPackageListRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getOMDSPackageListRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='OMDSPackageListResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getOMDSPackageListResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='OMDSPackageRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getOMDSPackageRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='OMDSPackageResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getOMDSPackageResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='ArcImageInfosRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getArcImageInfosRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='ArcImageInfosResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getArcImageInfosResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='ArcImageRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getArcImageRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='ArcImageResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getArcImageResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkClaimRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkClaimRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkBusinessObjectResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkClaimResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkPartnerRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkPartnerRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkBusinessObjectResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkPartnerResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkOfferRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkOfferRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkBusinessObjectResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkOfferResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkPolicyRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkPolicyRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='DeepLinkBusinessObjectResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="getDeepLinkPolicyResponse"/>
+         </annox:annotate>
+      </bindings>
+
+   </jaxb:bindings><!-- Ende omds3ServiceTypes -->
+
+   <!-- Basisfunktionen Namespace http://omds.vvo.at/types/omds3types/v1_4_0/on1basis -->
+   <jaxb:bindings schemaLocation="omds3_ON1_Basisfunktionen.xsd" node="/xs:schema" >
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on1basis" />
+      </jaxb:schemaBindings>
+
+      <bindings node="xs:complexType[@name='AddDocToBusinessCaseRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="AddDocToBusinessCaseRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='AddDocToBusinessCaseResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="AddDocToBusinessCaseResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetNumberOfDocumentsRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetNumberOfDocumentsRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetNumberOfDocumentsResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetNumberOfDocumentsResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetDocumentsOfObjectRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetDocumentsOfObjectRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetDocumentsOfObjectResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetDocumentsOfObjectResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetDocumentsOfPeriodRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetDocumentsOfPeriodRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetDocumentsOfPeriodResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetDocumentsOfPeriodResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='AcknowledgeDocumentsRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="AcknowledgeDocumentsRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='AcknowledgeDocumentsResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="AcknowledgeDocumentsResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetStateChangesRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetStateChangesRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetStateChangesResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetStateChangesResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+   <!-- Antrag-Common Namespace http://omds.vvo.at/types/omds3types/v1_4_0/on2antrag/common" -->
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Common.xsd" node="/xs:schema" >
+
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.common"/>
+      </jaxb:schemaBindings>
+
+      <jaxb:bindings node="//xs:element[@name='ConversionScopeRequest']//xs:element[@name='Vertrag']">
+         <jaxb:property name="vertraege">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Verträge, die in der Konvertierung behandelt werden sollen.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='Konvertierungsumfang_Type']//xs:element[@name='Vertrag']">
+         <jaxb:property name="vertraege">
+            <jaxb:javadoc><![CDATA[<p>Die Liste der Verträge, die in der Konvertierungsanforderung behandelt werden.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <jaxb:bindings node="//xs:complexType[@name='CreateOfferRequest_Type']//xs:element[@name='DokAnfordVermittler']">
+         <jaxb:property name="dokumentenAnforderungenVermittler">
+            <jaxb:javadoc><![CDATA[<p>Die Dokumente, welche der Vermittler für den Response anfordert.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+      <jaxb:bindings node="//xs:complexType[@name='CreateApplicationRequest_Type']//xs:element[@name='DokAnfordVermittler']">
+         <jaxb:property name="dokumentenAnforderungenVermittler">
+            <jaxb:javadoc><![CDATA[<p>Die Dokumente, welche der Vermittler für den Response anfordert.</p>]]></jaxb:javadoc>
+         </jaxb:property>
+      </jaxb:bindings>
+
+      <bindings node="xs:element[@name='ConversionScopeRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="ConversionScopeRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='ConversionScopeResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="ConversionScopeResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='ConversionProposalRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="ConversionProposalRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='ConversionProposalResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="ConversionProposalResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='ProductProposalRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="ProductProposalRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='ProductProposalResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="ProductProposalResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CalculateRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CalculateResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateOfferRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateOfferResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateApplicationRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateApplicationResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitApplicationRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitApplicationResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationResponse"/>
+         </annox:annotate>
+      </bindings>
+
+<!--      <jaxb:bindings node="//xs:complexType[@name='ProduktbausteinAuskunft_Type']//xs:element[@name='Klausel']">-->
+<!--         <jaxb:property name="Klauseln">-->
+<!--            <jaxb:javadoc><![CDATA[<p>Die Klauseln des Deckungsbausteins.</p>]]></jaxb:javadoc>-->
+<!--         </jaxb:property>-->
+<!--      </jaxb:bindings>-->
+<!--      <jaxb:bindings node="//xs:complexType[@name='ProduktbausteinAuskunft_Type']//xs:element[@name='Baustein']">-->
+<!--         <jaxb:property name="Bausteine">-->
+<!--            <jaxb:javadoc><![CDATA[<p>Die Unterbausteine des Deckungsbausteins.</p>]]></jaxb:javadoc>-->
+<!--         </jaxb:property>-->
+<!--      </jaxb:bindings>-->
+<!--      <jaxb:bindings node="//xs:complexType[@name='ProduktbausteinAuskunft_Type']//xs:element[@name='Attribut']">-->
+<!--         <jaxb:property name="Attribute">-->
+<!--            <jaxb:javadoc><![CDATA[<p>Die Attribute des Deckungsbausteins.</p>]]></jaxb:javadoc>-->
+<!--         </jaxb:property>-->
+<!--      </jaxb:bindings>-->
+<!--      <jaxb:bindings node="//xs:complexType[@name='ProduktbausteinAuskunft_Type']//xs:element[@name='Meldung']">-->
+<!--         <jaxb:property name="Meldungen">-->
+<!--            <jaxb:javadoc><![CDATA[<p>Die Meldungen des Deckungsbausteins.</p>]]></jaxb:javadoc>-->
+<!--         </jaxb:property>-->
+<!--      </jaxb:bindings>-->
+   </jaxb:bindings><!-- Ende Antrag Common -->
+
+   <!-- Antrag Kfz -->
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Kfz.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:complexType[@name='CalculateKfzRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateKfzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CalculateKfzResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateKfzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferKfzRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferKfzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferKfzResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferKfzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationKfzRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationKfzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationKfzResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationKfzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationKfzRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationKfzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationKfzResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationKfzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateVBRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateVBRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateVBResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateVBResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+   <!-- Antrag Kranken Namespace urn:at.vvo.omds.types.omds3.v1-6-0.on2antrag.kranken  -->
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Kranken.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.kranken"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:element[@name='CalculateKrankenRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateKrankenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CalculateKrankenResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateKrankenResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateOfferKrankenRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferKrankenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateOfferKrankenResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferKrankenResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateApplicationKrankenRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationKrankenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateApplicationKrankenResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationKrankenResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitApplicationKrankenRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationKrankenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitApplicationKrankenResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationKrankenResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+   <!-- Antrag Leben Namespace urn:at.vvo.omds.types.omds3.v1-5-0.on2antrag.leben  -->
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Leben.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.leben"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:complexType[@name='CalculateLebenRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateLebenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CalculateLebenResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateLebenResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferLebenRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferLebenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferLebenResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferLebenResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationLebenRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationLebenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationLebenResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationLebenResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationLebenRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationLebenRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationLebenResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationLebenResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+   <!-- Produktfinder Namespace urn:at.vvo.omds.types.omds3.v1-6-0.on2antrag.produktfinder  -->
+   <!--  <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Produktfinder.xsd">-->
+   <!--    <jaxb:schemaBindings>-->
+   <!--      <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.produktfinder"/>-->
+   <!--    </jaxb:schemaBindings>-->
+   <!--  </jaxb:bindings>-->
+
+   <!-- Antrag Rechtsschutz Namespace urn:at.vvo.omds.types.omds3.v1-4-0.on2antrag.rs -->
+
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Rechtsschutz.xsd" node="/xs:schema" >
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.rs"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:element[@name='CalculateRechtsschutzRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateRechtsschutzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CalculateRechtsschutzResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateRechtsschutzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateOfferRechtsschutzRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferRechtsschutzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateOfferRechtsschutzResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferRechtsschutzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateApplicationRechtsschutzRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationRechtsschutzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CreateApplicationRechtsschutzResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationRechtsschutzResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitApplicationRechtsschutzRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationRechtsschutzRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitApplicationRechtsschutzResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationRechtsschutzResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+
+   <!-- Antrag Sach-Privat Namespace urn:at.vvo.omds.types.omds3.v1-4-0.on2antrag.sachprivat -->
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_SachPrivat.xsd" node="/xs:schema" >
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.sachPrivat"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:complexType[@name='CalculateSachPrivatRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateSachPrivatRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CalculateSachPrivatResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateSachPrivatResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferSachPrivatRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferSachPrivatRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferSachPrivatResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferSachPrivatResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationSachPrivatRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationSachPrivatRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationSachPrivatResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationSachPrivatResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationSachPrivatRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationSachPrivatRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationSachPrivatResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationSachPrivatResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+   <!-- Antrag Unfall Namespace urn:at.vvo.omds.types.omds3.v1-4-0.on2antrag.unfall  -->
+   <jaxb:bindings schemaLocation="omds3_ON2_Antrag_Unfall.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on2antrag.unfall"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:complexType[@name='CalculateUnfallRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateUnfallRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CalculateUnfallResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CalculateUnfallResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferUnfallRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferUnfallRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateOfferUnfallResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateOfferUnfallResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationUnfallRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationUnfallRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CreateApplicationUnfallResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CreateApplicationUnfallResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationUnfallRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationUnfallRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitApplicationUnfallResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitApplicationUnfallResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+   <!-- Vertrag Namespace http://omds.vvo.at/types/omds3types/v1_4_0/on3vertrag  -->
+
+   <!-- Partner Namespace http://omds.vvo.at/types/omds3types/v1_4_0/on4partner -->
+   <!--  <jaxb:bindings schemaLocation="omds3_ON4_Partner.xsd">-->
+   <!--    <jaxb:schemaBindings>-->
+   <!--      <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on4partner"/>-->
+   <!--    </jaxb:schemaBindings>-->
+   <!--  </jaxb:bindings>-->
+
+   <!-- Schaden Namespace "urn:at.vvo.omds.types.omds3.v1-4-0.on7schaden" -->
+   <jaxb:bindings schemaLocation="omds3_ON7_Schaden.xsd" node="/xs:schema">
+      <jaxb:schemaBindings>
+         <jaxb:package name="at.vvo.omds.types.omds3.r2025_05.on7schaden"/>
+      </jaxb:schemaBindings>
+      <bindings node="xs:complexType[@name='CheckClaimRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CheckClaimRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='CheckClaimResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CheckClaimResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitClaimRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitClaimRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SubmitClaimResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitClaimResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='AddInformationToClaimRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="AddInformationToClaimRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='AddInformationToClaimResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="AddInformationToClaimResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetClaimRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetClaimRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='GetClaimResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="GetClaimResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SearchClaimRequest_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SearchClaimRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:complexType[@name='SearchClaimResponse_Type']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SearchClaimResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CheckCoverageRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CheckCoverageRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='CheckCoverageResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="CheckCoverageResponse"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitReceiptRequest']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitReceiptRequest"/>
+         </annox:annotate>
+      </bindings>
+      <bindings node="xs:element[@name='SubmitReceiptResponse']">
+         <annox:annotate>
+            <annox:annotate annox:class="jakarta.xml.bind.annotation.XmlRootElement" name="SubmitReceiptResponse"/>
+         </annox:annotate>
+      </bindings>
+   </jaxb:bindings>
+
+</bindings>

src/main/resources/def/r2025_27/omds3ServiceTypes.xsd

@@ -0,0 +1,693 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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>

src/main/resources/def/r2025_27/omds3_ON1_Basisfunktionen.xsd

@@ -0,0 +1,619 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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"/>
+			<!-- ServiceFault ist deprecated, es sollte im Fehlerfall bevorzugt ein echter Soap-Fault geworfen werden -->
+		</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 des Dokumenteneingangs durch den Makler</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type"/>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- POST - SERVICE -->
+	<xsd:element name="GetEnvelopesRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt fuer das Abrufen der Post 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 die Post bezogen werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Von" type="omds:Datum-Zeit2"/>
+						<xsd:element name="Bis" type="omds:Datum-Zeit2" minOccurs="0"/>
+						<xsd:element name="Binaerdaten" type="xsd:boolean" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Wenn "wahr", werden direkt die Binärdaten der Dokumente im Response retourniert, andernfalls werden nur Metadaten der Dokumente retourniert.	</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="NurNichtabgeholte" type="xsd:boolean" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Optionales Feature, nicht jeder Provider muss dies unterstützen.</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:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="GetEnvelopesResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt fuer das Abrufen der Post durch Vermittler bzw. seinen technischen Dienstleister</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cst:CommonResponse_Type">
+					<xsd:sequence>
+						<xsd:element name="AuthFilter" type="cst:AuthorizationFilter" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Der Ordnungsbegriff (z.B. Vermittlernummer, MaklerId), für welche die Post enthalten ist.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<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="Von" type="omds:Datum-Zeit2"/>
+						<xsd:element name="Bis" type="omds:Datum-Zeit2"/>
+						<xsd:element name="Umschlag" type="cst:Envelope_Type" maxOccurs="unbounded"/>
+						<xsd:element name="Bestaetigungstoken" type="xsd:string" minOccurs="0">
+							<xsd:annotation>
+								<xsd:documentation>Ein Token, mit welchem der erfolgreiche Bezug von Binärdaten von Dokumenten über den Service AcknowledgeEnvelopes bestätigt werden kann. Der Token ist nur enthalten, wenn in diesem Response Binärdaten enthalten sind. Die Bestätigung bezieht sich nie auf angeforderte, aber in diesem Response nicht gelieferte Binärdaten.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="AcknowledgeEnvelopesRequest">
+		<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 MaklerId, für den Posterhalt bestätigt werden soll.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+						<xsd:element name="Bestaetigungstoken" type="xsd:string">
+							<xsd:annotation>
+								<xsd:documentation>Ein Token, welcher den erfolgreichen Bezug von Binärdaten von Dokumenten bestätigt. Dieser wird im Response von GetEnvelopes übermittelt.</xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="AcknowledgeEnvelopesResponse">
+		<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>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_Common.xsd

@@ -0,0 +1,885 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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>
+								Liste aller benötigten Personen, welche dann über ihre Rolle oder im Produktbaum referenziert werden.
+								In der Berechnung versucht man in der Regel, ohne Personenobjekte sein Auslangen zu finden.
+								Werden Personenmerkmale als Tarifmerkmale benötigt (Geburtsdatum, PLZ), so können diese auch
+								im "normalen" Produktbaum als Merkmale aufgenommen werden. Es sind aber Ausnahmen denkbar,
+								in denen man auch in Berechnen mit Personenobjekten
+								arbeiten möchte, z.B. um persönliche Treuerabatte in der Berechnung abbilden zu können oder wenn man
+								die persönlichen Merkmale einheitlich über alle BOA-Phase modellieren
+								möchte und sie nicht im Produktbaum nochmals auftreten sollen.
+							</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="ProductProposalRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Request für Product-Proposal</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonRequest_Type">
+				<xsd:sequence>
+					<xsd:element name="Sparte" type="xsd:string" minOccurs="0">
+						<xsd:annotation>
+							<xsd:documentation>Optional eine Sparte, für den ein Vorschlag erzeugt werden soll.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="Kontextinfo" type="ProposalContext_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Kontextinformationen, welche in den Produktvorschlag einfließen sollen.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProductProposalResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Response für Product-Proposal</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:CommonResponse_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="cst:Verkaufsprodukt_Type" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Vorschlaege Verkaufsprodukt, müssen mit Calculate berechenbar sein, dürfen Prämien enthalten.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProposalContext_Type" abstract="true">
+		<xsd:annotation>
+			<xsd:documentation>Abstrakter Typ für Kontextinformationen im Product-Proposal-Request</xsd:documentation>
+		</xsd:annotation>
+	</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: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 eines Vertrags oder 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:element name="ProductProposalRequest" type="ProductProposalRequest_Type">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für Produktvorschlag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="ProductProposalResponse" type="ProductProposalResponse_Type">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für Produktvorschlag</xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+	<xsd:element name="CalculateRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Requestobjekts für eine Berechnung</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="CalculateRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsanfrage" type="SpezBerechnungGen_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CalculateResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Responseobjekts für eine Berechnung</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="CalculateResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsantwort" type="SpezBerechnungGen_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Offerterstellung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Typ des Requestobjekts für eine Erstellung eines Offerts</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="CreateOfferRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertanfrage" type="SpezOffert_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Offerterstellung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Responseobjekts für eine Erstellung eines Offerts</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="CreateOfferResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertantwort" type="SpezOffert_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragserzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Requestobjekts für die Erstellung eines Antrags</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="CreateApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntrag_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragserzeugung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>Type des Responseobjekts für die Erstellung eines Antrags</xsd:documentation>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="CreateApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntrag_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Antragsüberleitung</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="SubmitApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntrag_Type" minOccurs="0"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt für die Antragsüberleitung</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="SubmitApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntrag_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<!-- Generisches Calc basierend auf Produktmodell -->
+	<xsd:complexType name="SpezBerechnungGen_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für den Schritt Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="SpezBerechnung_Type">
+				<xsd:sequence>
+					<xsd:element name="Verkaufsprodukt" type="cst:Verkaufsprodukt_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+<!--	<xsd:complexType name="CalculateRequestAuskunft_Type">-->
+<!--		<xsd:annotation>-->
+<!--			<xsd:documentation>Typ des Requestobjekts für eine Berechnung Unfall</xsd:documentation>-->
+<!--		</xsd:annotation>-->
+<!--		<xsd:complexContent>-->
+<!--			<xsd:extension base="CalculateRequestGen_Type">-->
+<!--				<xsd:sequence>-->
+<!--					<xsd:element name="Berechnungsanfrage" type="SpezBerechnung_Type"/>-->
+<!--				</xsd:sequence>-->
+<!--			</xsd:extension>-->
+<!--		</xsd:complexContent>-->
+<!--	</xsd:complexType>-->
+<!--	<xsd:complexType name="CalculateResponseAuskunft_Type">-->
+<!--		<xsd:annotation>-->
+<!--			<xsd:documentation>Typ des Responseobjekts für eine Berechnung</xsd:documentation>-->
+<!--		</xsd:annotation>-->
+<!--		<xsd:complexContent>-->
+<!--			<xsd:extension base="CalculateResponseGen_Type">-->
+<!--				<xsd:sequence>-->
+<!--					<xsd:element name="Berechnungsantwort" type="SpezBerechnung_Type"/>-->
+<!--				</xsd:sequence>-->
+<!--			</xsd:extension>-->
+<!--		</xsd:complexContent>-->
+<!--	</xsd:complexType>-->
+<!--	<xsd:element name="CalculateRequestAuskunft" type="CalculateRequestAuskunft_Type">-->
+<!--		<xsd:annotation>-->
+<!--			<xsd:documentation>Requestobjekt für die Berechnung</xsd:documentation>-->
+<!--		</xsd:annotation>-->
+<!--	</xsd:element>-->
+<!--	<xsd:element name="CalculateResponseAuskunft" type="CalculateResponseAuskunft_Type">-->
+<!--		<xsd:annotation>-->
+<!--			<xsd:documentation>Responseobjekt für die Berechnung</xsd:documentation>-->
+<!--		</xsd:annotation>-->
+<!--	</xsd:element>-->
+<!--	<xsd:complexType name="ProduktbausteinAuskunft_Type" abstract="true">-->
+<!--		<xsd:sequence>-->
+<!--			<xsd:element name="Klausel" type="omds:KLAUSEL_Type" minOccurs="0" maxOccurs="unbounded" />-->
+<!--			<xsd:element name="Baustein" type="UnterbausteinAuskunft_Type" minOccurs="0" maxOccurs="unbounded"/>-->
+<!--			<xsd:element name="Attribut" type="cst:Attribut_Type" minOccurs="0" maxOccurs="unbounded" />-->
+<!--			<xsd:element name="Meldung" type="cst:ServiceFault" minOccurs="0" maxOccurs="unbounded" />-->
+<!--		</xsd:sequence>-->
+<!--		<xsd:attribute name="id" type="xsd:string" />-->
+<!--		<xsd:attribute name="name" type="xsd:string" use="required" />-->
+<!--		<xsd:attribute name="from" type="xsd:date" />-->
+<!--		<xsd:attribute name="to" type="xsd:date" />-->
+<!--		<xsd:attribute name="minOccurrences" type="xsd:int" use="required"/>-->
+<!--		<xsd:attribute name="maxOccurrences" type="xsd:int" />-->
+<!--		<xsd:attribute name="type" type="xsd:string" />-->
+<!--	</xsd:complexType>-->
+<!--	<xsd:complexType name="UnterbausteinAuskunft_Type">-->
+<!--		<xsd:complexContent>-->
+<!--			<xsd:extension base="ProduktbausteinAuskunft_Type">-->
+<!--				<xsd:attribute name="optional" type="xsd:boolean" >-->
+<!--					<xsd:annotation><xsd:documentation>-->
+<!--						Ob der Baustein optional ist. Diese Information muss vom Provider im Response zwingend zur Verfügung gestellt werden.-->
+<!--						Der Client muss diese Information im Request nicht schicken.-->
+<!--					</xsd:documentation></xsd:annotation>-->
+<!--				</xsd:attribute>-->
+<!--				<xsd:attribute name="default" type="xsd:boolean" ><xsd:annotation><xsd:documentation>-->
+<!--					Bei optionalen Bausteinen, ob es sich aus Sicht des Providers um ein Default-Element des Produktbaums handelt.-->
+<!--					Default-Elemente sind optionale Elemente, welche beim Vorschlag immer als inkludiert zurückgegeben werden.-->
+<!--				</xsd:documentation></xsd:annotation></xsd:attribute>-->
+<!--				<xsd:attribute name="included" type="xsd:boolean" ><xsd:annotation><xsd:documentation>-->
+<!--					Ob der Baustein inkludiert ist. Ist vom Serviceprovider im Response immer zu befüllen. Der Client muss es nicht-->
+<!--					befüllen. Wenn der Client das Attribut nicht schickt, wird es als true interpretiert.-->
+<!--				</xsd:documentation></xsd:annotation></xsd:attribute>-->
+<!--			</xsd:extension>-->
+<!--		</xsd:complexContent>-->
+<!--	</xsd:complexType>-->
+<!--	<xsd:complexType name="VerkaufsproduktAuskunft_Type">-->
+<!--		<xsd:annotation><xsd:documentation>Oberste Ebene von Produktbausteinen</xsd:documentation></xsd:annotation>-->
+<!--		<xsd:complexContent>-->
+<!--			<xsd:extension base="ProduktbausteinAuskunft_Type">-->
+<!--				<xsd:sequence>-->
+<!--				</xsd:sequence>-->
+<!--				<xsd:attribute name="vtgbeg" type="xsd:date" use="required"/>-->
+<!--			</xsd:extension>-->
+<!--		</xsd:complexContent>-->
+<!--	</xsd:complexType>-->
+
+
+</xsd:schema>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_Kfz.xsd

@@ -0,0 +1,719 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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:VerkaufsproduktGenerisch_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:ProduktGenerisch_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>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_Kranken.xsd

@@ -0,0 +1,250 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_Leben.xsd

@@ -0,0 +1,341 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_Rechtsschutz.xsd

@@ -0,0 +1,246 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="urn:at.vvo.omds.types.omds3types.v1-4-0.on2antrag.rs"
+						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.rs"
+						elementFormDefault="qualified" attributeFormDefault="qualified" version="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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="VerkaufsproduktRechtsschutz_Type" final="#all">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Verkaufsprodukt in der Sparte Rechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:VerkaufsproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="Produkte" type="ProduktRechtsschutz_Type" maxOccurs="unbounded"/>
+					<xsd:element name="Zusatzprodukte" type="cst:ProduktGenerisch_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersicherteInteressen" type="cst:VersichertesInteresse_Type" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Liste der versicherten Interessen, wobei hier nur ein abstrakter Typ vorgegeben ist. Die einzelnen versicherten Interessen können dann über die laufende Nummer referenziert werden.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ProduktRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Produkt in der Sparte Rechtsschutz. 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:ProduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="ElementarprodukteRechtsschutz" type="ElementarproduktRechtsschutz_Type" minOccurs="0" maxOccurs="unbounded"/>
+					<xsd:element name="VersInteressenRefLfNr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Bezug auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="ElementarproduktRechtsschutz_Type">
+		<xsd:annotation>
+			<xsd:documentation>Typ für ein Elementarprodukt in der Sparte Rechtsschutz. Von diesem Typ werden etwaige Standard-Deckungen abgeleitet, siehe Vertragsrechtsschutz_Type. Von diesem Typ können einzelne VUs aber auch ihre eigenen Elementarprodukte ableiten, wenn sie möchten.</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="cst:ElementarproduktGenerisch_Type">
+				<xsd:sequence>
+					<xsd:element name="VersInteressenRefLfNr" type="xsd:unsignedShort" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation>Bezug auf versicherte Interessen</xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Der Typ Vertragsrechtsschutz_Type ist ein Beispiel für einen normierten Untertyp. In dieser Form können auch VUs eigene Untertypen definieren -->
+	<xsd:simpleType name="OertlicherGeltungsbereichCd_Type">
+		<xsd:annotation>
+			<xsd:documentation>Code für den örtlichen Geltungsbereichs</xsd:documentation>
+		</xsd:annotation>
+		<xsd:restriction base="xsd:unsignedByte">
+			<xsd:enumeration value="1">
+				<xsd:annotation>
+					<xsd:documentation>Österreich</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="2">
+				<xsd:annotation>
+					<xsd:documentation>EU</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="3">
+				<xsd:annotation>
+					<xsd:documentation>Europa geographisch</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="4">
+				<xsd:annotation>
+					<xsd:documentation>EWR</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="5">
+				<xsd:annotation>
+					<xsd:documentation>weltweit</xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- Typen für die Schritte in BOA -->
+	<xsd:complexType name="SpezBerechnungRechtsschutz_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="VerkaufsproduktRechtsschutz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezOffertRechtsschutz_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="VerkaufsproduktRechtsschutz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="SpezAntragRechtsschutz_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="VerkaufsproduktRechtsschutz_Type"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- Typen und Elemente für die Methoden -->
+	<xsd:element name="CalculateRechtsschutzRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Berechnung Rechtsschutz</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CalculateRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsanfrage" type="SpezBerechnungRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CalculateRechtsschutzResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt bei der Rechtsschutz-Berechnung</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CalculateResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Berechnungsantwort" type="SpezBerechnungRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferRechtsschutzRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für eine Erstellung eines Rechstsschutz-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateOfferRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertanfrage" type="SpezOffertRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateOfferRechtsschutzResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt bei der Erstellung eines Rechtsschutz-Offerts</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateOfferResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Offertantwort" type="SpezOffertRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationRechtsschutzRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requestobjekt für die Erstellung eines Rechtsschutzantrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntragRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="CreateApplicationRechtsschutzResponse">
+		<xsd:annotation>
+			<xsd:documentation>Responseobjekt bei der Erstellung eines Rechtsschutzantrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:CreateApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntragRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationRechtsschutzRequest">
+		<xsd:annotation>
+			<xsd:documentation>Requests, um den Antrag einzureichen</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:SubmitApplicationRequestGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsanfrage" type="SpezAntragRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<xsd:element name="SubmitApplicationRechtsschutzResponse">
+		<xsd:annotation>
+			<xsd:documentation>Response nach dem Einreichen des Antrags</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ac:SubmitApplicationResponseGen_Type">
+					<xsd:sequence>
+						<xsd:element name="Antragsantwort" type="SpezAntragRechtsschutz_Type"/>
+					</xsd:sequence>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+</xsd:schema>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_SachPrivat.xsd

@@ -0,0 +1,688 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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" maxOccurs="unbounded"/>
+				</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>

src/main/resources/def/r2025_27/omds3_ON2_Antrag_Unfall.xsd

@@ -0,0 +1,246 @@
+<?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="2025.27-MINOR">
+	<xsd:import namespace="urn:omds20" schemaLocation="omds217-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>

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

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>

src/test/java/omdsclient/OmdsclientApplicationTests.java

@@ -0,0 +1,27 @@
+package omdsclient;
+
+import at.vvo.omds.client.api.SOAPConnector;
+import at.vvo.omds.client.api.UnfallCalcService;
+import at.vvo.omds.client.api.unfall.*;
+import org.junit.jupiter.api.Test;
+
+import java.util.logging.Logger;
+
+public class OmdsclientApplicationTests {
+
+    Logger log = Logger.getLogger(OmdsclientApplicationTests.class.getName());
+    SOAPConnector soapConnector = new SOAPConnector();
+    UnfallCalcService serviceWst = new UnfallCalcService(soapConnector);
+
+    @Test
+    public void contextLoads() throws Exception {
+        VerkaufsproduktUnfall input = DefaultUnfallBuilder.createDefault();
+        log.info(input.toString());
+
+        // Berechnung
+        VerkaufsproduktUnfall result = serviceWst.calc(input);
+
+        // zeige Ergebnis
+        log.info(result.toString());
+    }
+}

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
+        }
+    }
+}