﻿<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="PuzzleQuery" targetNamespace="http://schemas.webs.idu.de/cardo3/Puzzle/Query" elementFormDefault="qualified" xmlns="http://schemas.webs.idu.de/cardo3/Puzzle/Query" xmlns:mstns="http://schemas.webs.idu.de/cardo3/Puzzle/Query" xmlns:xs="http://www.w3.org/2001/XMLSchema">
	<!--
///////////////////////////////////////////////////////
  Alles rund um Suchabfragen
///////////////////////////////////////////////////////
-->
	<!--
		Hinweise für Vergleiche von SingleComparisonType
	-->
	<xs:simpleType name="CompareBehaviorType">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Default">
				<xs:annotation>
					<xs:documentation>
						Standard-Suche, Case Vergleich von Strings. OR Vergleich, wenn mehrere Werte übergeben wurden.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CompareStringsCaseInSensitiv">
				<xs:annotation>
					<xs:documentation>
						String-Vergleich ohne Beachtung der Groß-/Kleinschreibung durchführen.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="CompareCollectionsWithAnd">
				<xs:annotation>
					<xs:documentation>
						Wenn bei einer Abfrage eine Auflistung übergeben wird, werden die Werte per Default mit OR verglichen, wenn diese Flag gesetzt ist, wird stattdessen AND verwendet.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<!--
	Einfache Vergleichsoperatoren.
	Hinweis: Identisch mit IDU.DB.QueryBuilder.CompareOperator
	 -->
	<xs:simpleType name="OperatorType">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Equal" />
			<xs:enumeration value="NotEqual" />
			<xs:enumeration value="GreaterEqual" />
			<xs:enumeration value="LessEqual" />
			<xs:enumeration value="Greater" />
			<xs:enumeration value="Less" />
			<xs:enumeration value="Like" />
			<xs:enumeration value="NotLike" />
			<xs:enumeration value="In" />
			<xs:enumeration value="NotIn" />
			<xs:enumeration value="Between" />
			<xs:enumeration value="IsNull" />
			<xs:enumeration value="IsNotNull" />
		</xs:restriction>
	</xs:simpleType>
	<!--
	 Kombinationen
	 -->
	<xs:simpleType name="JoinType">
		<xs:restriction base="xs:string">
			<xs:enumeration value="And">
			</xs:enumeration>
			<xs:enumeration value="Or">
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="AnyComparisonBaseType" abstract="true">
	</xs:complexType>
	<!--
	 Basisklasse für alle Verknüpfungen
	 -->
	<xs:complexType name="IkxComparisonBaseType" abstract="true">
		<xs:complexContent>
			<xs:extension base="AnyComparisonBaseType"></xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- Keine Abfrage -->
	<xs:complexType name="NullComparisionType" abstract="false" final="#all">
		<xs:complexContent>
			<xs:extension base="IkxComparisonBaseType" />
		</xs:complexContent>
	</xs:complexType>
	<!--
    Ein spezieller Handler für Vergleiche
  -->
	<xs:complexType name="SpecialComparisonType" abstract="false" final="#all">
		<xs:complexContent>
			<xs:extension base="IkxComparisonBaseType">
				<xs:sequence>
					<xs:element name="HandlerTypeName" type="netString" nillable="false">
						<xs:annotation>
							<xs:documentation>
								Der .Net Typename eines registrierten Handlers.
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:element name="CompareType" type="OperatorType" minOccurs="1" maxOccurs="1"  default="Equal"/>
					<xs:element name="Method" type="netString" nillable="false">
						<xs:annotation>
							<xs:documentation>
								Der Name der öffentlichen Methode des HandlerTypeName. Es wird Groß-/Kleinschreibung unterschieden.
							</xs:documentation>
						</xs:annotation>
					</xs:element>
					<xs:sequence minOccurs="1" maxOccurs="unbounded">
						<xs:element name="Argument">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="Value" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
								</xs:sequence>
								<xs:attribute name="name" use="required" type="netString"></xs:attribute>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
	 Einfacher Vergleich
	-->
	<xs:complexType name="SingleComparisonType" abstract="false" final="#all">
		<xs:complexContent>
			<xs:extension base="IkxComparisonBaseType">
				<xs:sequence>
					<xs:choice>
						<xs:element name="EntityPath" type="xs:string" nillable="false" />
						<xs:element name="PuzzleNodeColumn" type="PuzzleNodeColumns" nillable="false"/>
					</xs:choice>
					<xs:element name="Is" type="OperatorType" minOccurs="1" maxOccurs="1">
					</xs:element>
					<xs:element name="Value" type="xs:string" maxOccurs="unbounded" minOccurs="1" />
				</xs:sequence>
				<xs:attribute name="negate" default="false" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>
							Verneint den gesamten Ausdruck.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
				<xs:attribute name="compareBehavior" default="CompareStringsCaseInSensitiv">
					<xs:simpleType>
						<xs:list itemType="CompareBehaviorType">
						</xs:list>
					</xs:simpleType>
				</xs:attribute>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
	 Basisklasse für And / Or Verknüpfung
	 -->
	<xs:complexType name="CombinedComparisonBaseType" abstract="true">
		<xs:complexContent>
			<xs:extension base="IkxComparisonBaseType">
				<xs:sequence>
					<xs:choice minOccurs="2" maxOccurs="unbounded">
						<xs:element name="SingleComparison" type="SingleComparisonType">
						</xs:element>
						<xs:element name="SpecialComparison" type="SpecialComparisonType">
						</xs:element>
						<xs:element name="And" type="CombinedComparisonAndType">
						</xs:element>
						<xs:element name="Or" type="CombinedComparisonOrType">
						</xs:element>
					</xs:choice>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="IkxRootComparsionType">
		<xs:complexContent>
			<xs:extension base="IkxComparisonBaseType">
				<xs:sequence>
					<xs:choice minOccurs="1" maxOccurs="1">
						<xs:element name="SingleComparison" type="SingleComparisonType">
						</xs:element>
						<xs:element name="SpecialComparison" type="SpecialComparisonType">
						</xs:element>
						<xs:element name="And" type="CombinedComparisonAndType">
						</xs:element>
						<xs:element name="Or" type="CombinedComparisonOrType">
						</xs:element>
					</xs:choice>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<!--
	 Und - Verknüpfung
	 -->
	<xs:complexType name="CombinedComparisonAndType" final="#all">
		<xs:complexContent>
			<xs:extension base="CombinedComparisonBaseType">
				<xs:attribute name="negate" default="false" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>
							Verneint den gesamten Ausdruck.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
	 Or - Verknüpfung
	 -->
	<xs:complexType name="CombinedComparisonOrType" final="#all">
		<xs:complexContent>
			<xs:extension base="CombinedComparisonBaseType">
				<xs:attribute name="negate" default="false" type="xs:boolean">
					<xs:annotation>
						<xs:documentation>
							Verneint den gesamten Ausdruck.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
	PuzzleNode spezifische Abfragen
	-->
	<!--
	 Basisklasse für alle Verknüpfungen
	 -->
	<!--
  <xs:complexType name="PuzzleNodeComparisonBase" abstract="true">
	<xs:complexContent>
	  <xs:extension base="AnyComparisonBaseType"></xs:extension>
	</xs:complexContent>
  </xs:complexType>
  -->
	<!--
	Bei der Abfrage der Nodes gibt es keinen Pfad, daher die Auflistung hier
	-->
	<xs:simpleType name="PuzzleNodeColumns">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Title">
				<xs:annotation>
					<xs:documentation>
						Die Titelspalte des Knotens.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="PuzzleNodeId">
				<xs:annotation>
					<xs:documentation>
						Die Knoten-ID (PuzzleNodeId). Erwartet wird dann in Value eine Liste/Einzelwert von Int's.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Creator">
				<xs:annotation>
					<xs:documentation>
						Der Loginname des Erstellers des Knotens.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Modifier">
				<xs:annotation>
					<xs:documentation>
						Der Loginname des Bearbeiters des Knotens.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Created">
				<xs:annotation>
					<xs:documentation>
						Das Erstellungsdatum des Knotens.
						Die Daten müssen als DateTime angegeben werden.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
			<xs:enumeration value="Modified">
				<xs:annotation>
					<xs:documentation>
						Das Erstellungsdatum des Knotens.
						Die Daten müssen als DateTime angegeben werden.
					</xs:documentation>
				</xs:annotation>
			</xs:enumeration>
		</xs:restriction>
	</xs:simpleType>
	<!--
	 Basisklasse für And / Or Verknüpfung
	 -->
	<!--
  <xs:complexType name="PuzzleNodeCombinedComparisonBaseType" abstract="true">
	<xs:complexContent>
	  <xs:extension base="PuzzleNodeComparisonBase">
		<xs:sequence>
		  <xs:choice minOccurs="2" maxOccurs="unbounded">
			<xs:element name="NodeComparison" type="PuzzleNodeComparisonType">
			</xs:element>
			<xs:element name="And" type="PuzzleNodeCombinedComparisonAndType">
			</xs:element>
			<xs:element name="Or" type="PuzzleNodeCombinedComparisonOrType">
			</xs:element>
		  </xs:choice>
		</xs:sequence>
	  </xs:extension>
	</xs:complexContent>
  </xs:complexType>
-->
	<!--
	 Puzzle-Node: Und - Verknüpfung
	 -->
	<!--
  <xs:complexType name="PuzzleNodeCombinedComparisonAndType" final="#all">
	<xs:complexContent>
	  <xs:extension base="PuzzleNodeCombinedComparisonBaseType">
	  </xs:extension>
	</xs:complexContent>
  </xs:complexType>
  -->
	<!--
	 Puzzle-Node: Or - Verknüpfung
	 -->
	<!--
  <xs:complexType name="PuzzleNodeCombinedComparisonOrType" final="#all">
	<xs:complexContent>
	  <xs:extension base="PuzzleNodeCombinedComparisonBaseType">
	  </xs:extension>
	</xs:complexContent>
  </xs:complexType>
  -->
	<!--
		Puzzle-Node: die Abfrage
	-->
	<!--
  <xs:complexType name="PuzzleNodeComparisonType">
	<xs:complexContent>
	  <xs:extension base="PuzzleNodeComparisonBase">
		<xs:sequence>
		  <xs:element name="Is" type="OperatorType" minOccurs="1" maxOccurs="1">
		  </xs:element>
		  <xs:element name="Value" type="xs:string" maxOccurs="unbounded" minOccurs="1" />
		</xs:sequence>
		<xs:attribute name="column" type="PuzzleNodeColumns" use="required"></xs:attribute>
		<xs:attribute name="compareBehavior" default="CompareStringsCaseInSensitiv">
		  <xs:simpleType>
			<xs:list itemType="CompareBehaviorType">
			</xs:list>
		  </xs:simpleType>
		</xs:attribute>
	  </xs:extension>
	</xs:complexContent>
  </xs:complexType>
  -->
	<!--
	Eine Abfrage, die auf die Node-Tabelle zugreift
	-->
	<!--
	<xs:complexType name="PuzzleNodeQueryType">
		<xs:complexContent>
			<xs:extension base="PuzzleNodeComparisonBase">
				<xs:sequence>
					<xs:choice minOccurs="1" maxOccurs="1">
						<xs:element name="NodeComparison" type="PuzzleNodeComparisonType">
						</xs:element>
						<xs:element name="And" type="PuzzleNodeCombinedComparisonAndType">
						</xs:element>
						<xs:element name="Or" type="PuzzleNodeCombinedComparisonOrType">
						</xs:element>
					</xs:choice>
					<xs:choice minOccurs="0" maxOccurs="1">
						<xs:element name="AndData" type="IkxRootComparsionType">
						</xs:element>
						<xs:element name="OrData" type="IkxRootComparsionType">
						</xs:element>
					</xs:choice>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	-->
	<!--
	 Ein Filter-Typ
	 -->
	<xs:complexType name="PuzzleFilterType">
		<xs:choice>
			<!--
			<xs:element name="PuzzleNodeQuery" type="PuzzleNodeQueryType"/>
			-->
			<xs:element name="NullComparision" type="NullComparisionType">
			</xs:element>
			<xs:element name="SingleComparison" type="SingleComparisonType">
			</xs:element>
			<xs:element name="SpecialComparison" type="SpecialComparisonType">
			</xs:element>
			<xs:element name="And" type="CombinedComparisonAndType">
			</xs:element>
			<xs:element name="Or" type="CombinedComparisonOrType">
			</xs:element>
		</xs:choice>
	</xs:complexType>
	<!--
	 Das Query - Element
	 -->
	<xs:element name="Query">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="PuzzleCategoryId" type="categoryString" minOccurs="1" maxOccurs="unbounded" nillable="false" />
				<xs:choice minOccurs="1" maxOccurs="1">
					<!--
				  <xs:element name="PuzzleNodeQuery" type="PuzzleNodeQueryType">
					</xs:element>
				  -->
					<xs:element name="NullComparision" type="NullComparisionType">
					</xs:element>
					<xs:element name="SingleComparison" type="SingleComparisonType">
					</xs:element>
					<xs:element name="SpecialComparison" type="SpecialComparisonType">
					</xs:element>
					<xs:element name="And" type="CombinedComparisonAndType">
					</xs:element>
					<xs:element name="Or" type="CombinedComparisonOrType">
					</xs:element>
				</xs:choice>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
	<!-- Nur für Testzwecke 
  <xs:element name="QueryX">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="PuzzleFilterType">
          <xs:sequence>
            <xs:element name="PuzzleCategoryId" type="categoryString" minOccurs="1" maxOccurs="unbounded" nillable="false" />
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
    </xs:element>
  -->
	<!--
///////////////////////////////////////////////////////
Statistiken
///////////////////////////////////////////////////////
-->
	<!-- 
    ReportElementBaseType
    Basisklasse für Aggregate, enthält einige allgemeine Eigenschaften wie z.B. Ausgabehinweise
  -->
	<xs:complexType abstract="true" name="ReportElementBaseType">
		<xs:sequence>
			<xs:element name="Format" type="xs:string" minOccurs="0" maxOccurs="1">
				<xs:annotation>
					<xs:documentation>
						Eine Zeichenfolge für die formatierte Ausgabe. Der Platzhalter {0} (im .Net String-Format Stil) kann für das Einsetzen des Ergebnisses verwendet werden.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="FormatOnNull" type="xs:string" minOccurs="0" maxOccurs="1">
				<xs:annotation>
					<xs:documentation>
						Eine Zeichenfolge für die formatierte Ausgabe, wenn der Wert null ist. Ist NullFormat nicht definiert, wird Format verwendet.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
			<xs:element name="ColumnSqlStatmentFormat" type="xs:string" minOccurs="0" maxOccurs="1" nillable="false">
				<xs:annotation>
					<xs:documentation>
						Eine optionale Anweisung, in die die Spalte eingebettet werden kann. Die Angabe erfolgt in Form eines .Net String-Formats.
						Übergeben wird immer der Parameter 0 (der Spaltenname).
						Mögliche Verwendung: z.B. ST_Area({0}) für die Aggregierung einer Flächengröße.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>

		<xs:attribute type="xs:ID" name="columId" use="required">
			<xs:annotation>
				<xs:documentation>Eine eindeutige ID für diesen Ausdruck.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
	<!-- 
    ReportElementWithEntityBaseType 
    Erweitert ReportElementBaseType um Entitäts-Pfade
    -->
	<xs:complexType abstract="true" name="ReportElementWithEntityBaseType">
		<xs:complexContent>
			<xs:extension base="ReportElementBaseType">
				<xs:sequence>
					<xs:element name="EntityPath" maxOccurs="1" minOccurs="1" nillable="false" type="entityPathString">
						<xs:annotation>
							<xs:documentation>
								Der Pfad zur Entität, der Pfad muss auf einen Simple-Type zeigen (der vom Datentyp kompatibel zur Funktion ist).
								Es sollte nicht auf Elemente mit einer Häufigkeit > 1 gezeigt werden.
							</xs:documentation>
						</xs:annotation>
					</xs:element>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!-- 
    ReportAggregateFunctions.
    Enumeration von Aggregat-Funktionen. Die Namen sind identisch zu SQL Methoden
  -->
	<xs:simpleType name="ReportAggregateFunctions">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Min"/>
			<xs:enumeration value="Max"/>
			<xs:enumeration value="Avg"/>
			<xs:enumeration value="Sum"/>
			<xs:enumeration value="Count"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- ReportColumnAggregateType -->
	<xs:complexType name="ReportColumnAggregateType" final="#all">
		<xs:complexContent>
			<xs:extension base="ReportElementWithEntityBaseType">
				<xs:attribute name="func" type="ReportAggregateFunctions" use="required">
					<xs:annotation>
						<xs:documentation>
							Die Aggregatfunktion für die in Entity-Path angegebene Spalte.
						</xs:documentation>
					</xs:annotation>
				</xs:attribute>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
    ReportGroupByType
    Gruppierung nach einer Spalte
  -->
	<xs:complexType name="ReportGroupByType" final="#all">
		<xs:complexContent>
			<xs:extension base="ReportElementWithEntityBaseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
    Count(*)
  -->
	<xs:complexType name="ReportCountAllType" final="#all">
		<xs:complexContent>
			<xs:extension base="ReportElementBaseType">
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>
	<!--
  Der Berichts-Type für eine Abfrage an eine Puzzle-Kategorie
  -->
	<xs:complexType name="ReportType" final="#all">
		<xs:sequence>
			<xs:element name="Report" minOccurs="1" maxOccurs="unbounded" nillable="false">
				<xs:annotation>
					<xs:documentation>
						Die Definition der Spalten/Funktionen für einen Bericht.
					</xs:documentation>
				</xs:annotation>
				<xs:complexType>
					<xs:sequence>
						<xs:element name="ReportTitle" type="xs:string" nillable="true" minOccurs="0" maxOccurs="1">
							<xs:annotation>
								<xs:documentation>Ein optionaler Titel für diesen Bericht.</xs:documentation>
							</xs:annotation>
						</xs:element>
						<xs:element name="Aggregate" minOccurs="0" maxOccurs="unbounded" type="ReportColumnAggregateType">
							<xs:annotation>
								<xs:documentation>
									Liste der Aggregatfunktionen.
								</xs:documentation>
							</xs:annotation>
						</xs:element>
						<xs:element name="GroupBy" minOccurs="0" maxOccurs="1" nillable="false">
							<xs:complexType>
								<xs:sequence>
									<xs:element name="GroupColumn" minOccurs="1" maxOccurs="unbounded" nillable="false" type="ReportGroupByType"/>
								</xs:sequence>
							</xs:complexType>
						</xs:element>
						<xs:element name="CountAll" minOccurs="0" maxOccurs="1" nillable="true" type="ReportCountAllType"/>
					</xs:sequence>
					<xs:attribute type="xs:ID" use="optional" name="reportId" />
				</xs:complexType>
			</xs:element>
			<xs:element name="Filter" type="PuzzleFilterType" minOccurs="0" maxOccurs="1">
				<xs:annotation>
					<xs:documentation>
						Ein optionaler Filter.
					</xs:documentation>
				</xs:annotation>
			</xs:element>
		</xs:sequence>
	</xs:complexType>
	<xs:simpleType name="ReportValueTarget">
		<xs:restriction base="xs:string">
			<xs:enumeration value="RawValue"/>
			<xs:enumeration value="TextValue"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="ReportValuetAggregatedType">
		<xs:restriction base="xs:string">
			<xs:enumeration value="Sum"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:complexType name="ReportValueOfBaseType">
		<xs:attribute name="reportId" use="optional" type="xs:IDREF"/>
		<xs:attribute name="columId" use="required" type="xs:IDREF"/>
		<xs:attribute name="target" use="required" type="ReportValueTarget"/>
	</xs:complexType>

	<xs:element name="ReportValueOf">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="ReportValueOfBaseType">
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>
	<xs:element name="ReportAggregatedValueOf">
		<xs:complexType>
			<xs:complexContent>
				<xs:extension base="ReportValueOfBaseType">
					<xs:attribute name="func" use="required" type="ReportValuetAggregatedType"/>
				</xs:extension>
			</xs:complexContent>
		</xs:complexType>
	</xs:element>


	<xs:element name="ReportRowRepeater">
		<xs:complexType mixed="false">
			<xs:sequence>
				<xs:any namespace="##any" processContents="lax" maxOccurs="unbounded"></xs:any>
			</xs:sequence>
			<xs:attribute name="reportId" use="required" type="xs:IDREF"/>
			<xs:attribute name="orderByColumn" use="optional" type="xs:IDREF"/>
			<xs:attribute name="orderDescend" use="optional" type="xs:boolean"/>
		</xs:complexType>
	</xs:element>
	<xs:complexType name="AnyContent">
		<xs:complexContent mixed="true">
			<xs:restriction base="xs:anyType">
				<xs:sequence minOccurs="0">
					<xs:any namespace="##any" processContents="lax" maxOccurs="unbounded"></xs:any>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="EveryRowDependendAnyContent">
		<xs:complexContent>
			<xs:extension base="AnyContent">
				<xs:attribute name="exceptingFirstRow" type="xs:boolean"/>
				<xs:attribute name="exceptingLastRow" type="xs:boolean"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:element name="ReportRowDependendContent">
		<xs:complexType>
			<xs:choice>
				<xs:element name="FirstRow" type="EveryRowDependendAnyContent" minOccurs="1" maxOccurs="1">
					<xs:annotation>
						<xs:documentation>Wird bei nur bei der 1. Zeile ausgegeben.</xs:documentation>
					</xs:annotation>
				</xs:element>
				<xs:element name="EveryEvenRow" type="EveryRowDependendAnyContent" minOccurs="1" maxOccurs="1">
					<xs:annotation>
						<xs:documentation>Wird bei jeder geraden Zeile ausgegeben.</xs:documentation>
					</xs:annotation>
				</xs:element>
				<xs:element name="EveryOddRow" type="EveryRowDependendAnyContent" minOccurs="1" maxOccurs="1">
					<xs:annotation>
						<xs:documentation>Wird bei jeder ungeraden Zeile ausgegeben.</xs:documentation>
					</xs:annotation>
				</xs:element>
				<xs:element name="LastRow" type="EveryRowDependendAnyContent" minOccurs="0" maxOccurs="1">
					<xs:annotation>
						<xs:documentation>Wird bei nur der letzen Zeile ausgegeben.</xs:documentation>
					</xs:annotation>
				</xs:element>
			</xs:choice>
		</xs:complexType>
	</xs:element>
	<!--
    Bericht für eine Puzzle-Kategorie  
    -->
	<xs:element name="PuzzleReport">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="PuzzleCategoryId" type="categoryString" minOccurs="1" maxOccurs="1" nillable="false">
					<xs:annotation>
						<xs:documentation>
							Die Puzzle-Kategorie, für die der Bericht ermittelt werden soll.
						</xs:documentation>
					</xs:annotation>
				</xs:element>
				<xs:element name="Reports" type="ReportType" minOccurs="1" maxOccurs="1"></xs:element>
				<xs:element name="ReportOutput" minOccurs="0" maxOccurs="1" nillable="false">
					<xs:annotation>
						<xs:documentation>
							Enthält beliebigen Output. Die Elemente ReportValueOf,ReportRowRepeater und ReportRowDependend werden zusätzlich ausgewertet.
							Bsp.:
						</xs:documentation>
						<xs:documentation>
							<![CDATA[
<div>
<h1>Bericht 1</h1>
<table>
  <tr>
    <td>Anzahl</td>
    <td>&#160;</td>
    <td>
      <pzl:ReportValueOf columId="SumTotal" reportId="Alle" target="TextValue"/>
      (insgesamt <pzl:ReportValueOf columId="CountSumAvail" reportId="Alle" target="TextValue"/>)
    </td>
    <td>
      <pzl:ReportValueOf reportId="Alle" columId="SumTotal" target="TextValue"/>
    </td>
  </tr>
 </table>
</div>
                    ]]>
						</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:any namespace="##any" processContents="lax" maxOccurs="unbounded">
							</xs:any>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
			<xs:attribute name="includeDebugInfo" type="xs:boolean" default="false"></xs:attribute>
		</xs:complexType>
	</xs:element>
	<!--
///////////////////////////////////////////////////////
Einige allgemeine einfache Typen
///////////////////////////////////////////////////////
  -->
	<xs:simpleType name="categoryString">
		<xs:restriction base="xs:string">
			<xs:whiteSpace value="collapse">
			</xs:whiteSpace>
			<xs:maxLength value="255">
			</xs:maxLength>
			<xs:minLength value="1">
			</xs:minLength>
			<xs:pattern value="[A-Z]([A-Z\._0-9])*">
			</xs:pattern>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="entityPathString">
		<xs:annotation>
			<xs:documentation>
				Der Pfad ist immer in der Form: /CLASS_ID.ENTITY_ID/SUB_CLASS_ID.SUB_ENTITY_ID anzugeben.
			</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:whiteSpace value="collapse">
			</xs:whiteSpace>
			<xs:maxLength value="4000">
			</xs:maxLength>
			<xs:minLength value="1">
			</xs:minLength>
			<!-- <xs:pattern value="[A-Z|\._0-9|\\./]"> -->
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="netString">
		<xs:restriction base="xs:string">
			<xs:whiteSpace value="collapse">
			</xs:whiteSpace>
			<xs:maxLength value="400">
			</xs:maxLength>
			<xs:minLength value="1">
			</xs:minLength>
			<xs:pattern value="[(A-Z|a-z)]([(A-Z|a-z)\._0-9])*">
			</xs:pattern>
		</xs:restriction>
	</xs:simpleType>
</xs:schema>