XML Schema Documentation

Table of Contents

top

Schema Document Properties

Target Namespace http://software.in2p3.fr/lavoisier/application.xsd
Version 1.0
Element and Attribute Namespaces
  • Global element and attribute declarations belong to this schema's target namespace.
  • By default, local element declarations belong to this schema's target namespace.
  • By default, local attribute declarations have no namespace.

Declared Namespaces

Prefix Namespace
Default namespace http://software.in2p3.fr/lavoisier/application.xsd
xml http://www.w3.org/XML/1998/namespace
xs http://www.w3.org/2001/XMLSchema
ns1 http://software.in2p3.fr/lavoisier/application.xsd
Schema Component Representation
<xs:schema elementFormDefault="qualified" targetNamespace="http://software.in2p3.fr/lavoisier/application.xsd" version="1.0">
...
</xs:schema>
top

Global Declarations

Element: argument

Name argument
Type ns1:argument
Nillable no
Abstract no
XML Instance Representation
<ns1:argument
path-format=" pathFormat [0..1]"
name=" xs:string [1]"
eval=" xs:string [0..1]"
pattern=" xs:string [0..1]">
ns1:xs:string
</ns1:argument>
Schema Component Representation
<xs:element name="argument" type=" ns1:argument "/>
top

Element: authenticator

Name authenticator
Type ns1:authenticator
Nillable no
Abstract no
XML Instance Representation
<ns1:authenticator
authorized=" xs:string [0..1]"
type=" xs:string (value comes from list: {'X509Authenticator'|'CookieAuthenticator'|'KerberosHTMLFormAuthenticator'|'CASAuthenticator'|'WhiteListHTMLFormAuthenticator'|'KerberosHTTPBasicAuthenticator'|'OAuth2Authenticator'|'IPAddressAuthenticator'|'GuestAuthenticator'|'WhiteListHTTPBasicAuthenticator'|'SAML2Authenticator'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</ns1:authenticator>
Schema Component Representation
<xs:element name="authenticator" type=" ns1:authenticator "/>
top

Element: authenticators

Name authenticators
Type ns1:authenticators
Nillable no
Abstract no
XML Instance Representation
<ns1:authenticators
name=" xs:ID [0..1]">
<ns1:authenticator> ... </ns1:authenticator> [0..*]
</ns1:authenticators>
Schema Component Representation
<xs:element name="authenticators" type=" ns1:authenticators "/>
top

Element: authenticators-list

Name authenticators-list
Type ns1:authenticatorsList
Nillable no
Abstract no
XML Instance Representation
<ns1:authenticators-list>
<ns1:authenticators> ... </ns1:authenticators> [0..*]
</ns1:authenticators-list>
Schema Component Representation
<xs:element name="authenticators-list" type=" ns1:authenticatorsList "/>
top

Element: cache

Name cache
Type ns1:cache
Nillable no
Abstract no
XML Instance Representation
<ns1:cache
ttl=" xs:duration [0..1]"
exclusive=" xs:boolean [0..1]"
type=" xs:string (value comes from list: {'EmptyCache'|'MemoryCache'|'IndexedFileCache'|'FileCache'|'IndexedMemoryCache'|'BaseXCache'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
<ns1:trigger> ... </ns1:trigger> [1..*]
</ns1:cache>
Schema Component Representation
<xs:element name="cache" type=" ns1:cache "/>
top

Element: column

Name column
Type ns1:column
Nillable no
Abstract no
XML Instance Representation
<ns1:column
hidden=" xs:boolean [0..1]"
unit=" xs:string [0..1]"
order=" sortDirection [0..1]"
link=" xs:string [0..1]"
label=" xs:string [0..1]">
ns1:xs:string
</ns1:column>
Schema Component Representation
<xs:element name="column" type=" ns1:column "/>
top

Element: connector

Name connector
Type ns1:connector
Nillable no
Abstract no
XML Instance Representation
<ns1:connector
type=" xs:string (value comes from list: {'IndexedFileCacheConnector'|'FileCacheConnector'|'IndexedMemoryCacheConnector'|'SynchronousCacheConnector'|'RotatingCacheConnector'|'MemoryCacheConnector'|'EmptyCacheConnector'|'BaseXCacheConnector'|'PublicKeyConnector'|'PathConnector'|'LDAPConnector'|'RTDPConnector'|'StandardInputConnector'|'SetSystemPropertyConnector'|'XMLConnector'|'MidiFileConnector'|'XSLTConnector'|'FileConnector'|'StringConnector'|'HTTPConnector'|'FileNotifiableConnector'|'ShellConnector'|'JMXOperationConnector'|'DirectoryConnector'|'JMXConnector'|'ConfigurationCheckingConnector'|'DiffConnector'|'JWTConnector'|'RemctlConnector'|'ScalaConnector'|'SQLConnector'|'XPath2SQLConnector'|'SFTPConnector'|'SSHExecConnector'|'TelnetConnector'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
<ns1:fallback> ... </ns1:fallback> [0..1]
</ns1:connector>
Schema Component Representation
<xs:element name="connector" type=" ns1:connector "/>
top

Element: element

Name element
Type tns:element
Nillable no
Abstract no
XML Instance Representation
<ns1:element> tns:element </ns1:element>
Schema Component Representation
<xs:element name="element" type=" tns:element "/>
top

Element: element-create-as-parent

Name element-create-as-parent
Type tns:elementCreateAsParent
Nillable no
Abstract no
XML Instance Representation
<ns1:element-create-as-parent> tns:elementCreateAsParent </ns1:element-create-as-parent>
Schema Component Representation
<xs:element name="element-create-as-parent" type=" tns:elementCreateAsParent "/>
top

Element: element-ignore

Name element-ignore
Type tns:elementIgnore
Nillable no
Abstract no
XML Instance Representation
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore>
Schema Component Representation
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
top

Element: elements

Name elements
Type tns:elements
Nillable no
Abstract no
XML Instance Representation
<ns1:elements> tns:elements </ns1:elements>
Schema Component Representation
<xs:element name="elements" type=" tns:elements "/>
top

Element: entry

Name entry
Type ns1:entry
Nillable no
Abstract no
XML Instance Representation
<ns1:entry
key=" xs:string [0..1]"
eval=" xs:string [0..1]">
ns1:xs:string
</ns1:entry>
Schema Component Representation
<xs:element name="entry" type=" ns1:entry "/>
top

Element: exception

Name exception
Type ns1:exception
Nillable no
Abstract no
XML Instance Representation
<ns1:exception
type=" xs:string [1]"
predicate-on-message=" xs:string [0..1]"/>
Schema Component Representation
<xs:element name="exception" type=" ns1:exception "/>
top

Element: fallback

Name fallback
Type ns1:fallback
Nillable no
Abstract no
XML Instance Representation
<ns1:fallback
eval=" xs:string [0..1]">
<ns1:exception> ... </ns1:exception> [1..*]
</ns1:fallback>
Schema Component Representation
<xs:element name="fallback" type=" ns1:fallback "/>
top

Element: field

Name field
Type ns1:field
Nillable no
Abstract no
XML Instance Representation
<ns1:field
label=" xs:string [0..1]"
link=" xs:string [0..1]">
ns1:xs:string
</ns1:field>
Schema Component Representation
<xs:element name="field" type=" ns1:field "/>
top

Element: info

Name info
Type ns1:info
Nillable no
Abstract no
XML Instance Representation
<ns1:info>
Allow any elements from any namespace (skip validation). [0..*]
</ns1:info>
Schema Component Representation
<xs:element name="info" type=" ns1:info "/>
top

Element: namespace

Name namespace
Type ns1:namespace
Nillable no
Abstract no
XML Instance Representation
<ns1:namespace
uri=" xs:string [1]"
prefix=" xs:string [1]"/>
Schema Component Representation
<xs:element name="namespace" type=" ns1:namespace "/>
top

Element: namespaces

Name namespaces
Type ns1:namespaces
Nillable no
Abstract no
XML Instance Representation
<ns1:namespaces
eval=" xs:string [0..1]">
<ns1:entry> ... </ns1:entry> [0..*]
</ns1:namespaces>
Schema Component Representation
<xs:element name="namespaces" type=" ns1:namespaces "/>
top

Element: parameter

Name parameter
Type ns1:parameter
Nillable no
Abstract no
XML Instance Representation
<ns1:parameter
name=" xs:string [1] ?"
eval=" xs:string [0..1]">
<!-- Mixed content -->
<ns1:entry> ... </ns1:entry> [0..*]
Start Choice [0..*]
End Choice
</ns1:parameter>
Schema Component Representation
<xs:element name="parameter" type=" ns1:parameter "/>
top

Element: post-processors

Name post-processors
Type ns1:postProcessors
Nillable no
Abstract no
XML Instance Representation
<ns1:post-processors
name=" xs:ID [0..1]">
Start Choice [0..*]
<ns1:repeat> ... </ns1:repeat> [1]
<ns1:element> ... </ns1:element> [1]
<ns1:elements> ... </ns1:elements> [1]
<ns1:element-ignore> ... </ns1:element-ignore> [1]
<ns1:element-create-as-parent> ... </ns1:element-create-as-parent> [1]
<ns2:e> ... </ns2:e> [1]
<ns1:processor> ... </ns1:processor> [1]
End Choice
</ns1:post-processors>
Schema Component Representation
<xs:element name="post-processors" type=" ns1:postProcessors "/>
top

Element: pre-renderers

Name pre-renderers
Type ns1:preRenderers
Nillable no
Abstract no
XML Instance Representation
<ns1:pre-renderers
row-column=" xs:string [0..1]">
<ns1:namespace> ... </ns1:namespace> [0..*]
<ns1:title> ... </ns1:title> [0..1]
<ns1:field> ... </ns1:field> [0..*]
<ns1:row> ... </ns1:row> [1]
</ns1:pre-renderers>
Schema Component Representation
<xs:element name="pre-renderers" type=" ns1:preRenderers "/>
top

Element: processor

Name processor
Type ns1:processor
Nillable no
Abstract no
XML Instance Representation
<ns1:processor
match=" xs:string [1]"
disabled=" xs:string [0..1]"
type=" xs:string (value comes from list: {'XPathValidatorProcessor'|'MergeProcessor'|'MultiMergeProcessor'|'SelectAncestorProcessor'|'CopyProcessor'|'SelectGroupByProcessor'|'RenameWithXPathProcessor'|'SkeletonProcessor'|'EncodeProcessor'|'TemplateGeneratorProcessor'|'RenameProcessor'|'CDATAProcessor'|'MoveProcessor'|'LimitProcessor'|'InsertParentProcessor'|'SelectProcessor'|'RemoveHeaderProcessor'|'EventListBuilderProcessor'|'ChangeNamespaceProcessor'|'RemoveProcessor'|'ElementToAttributeProcessor'|'RemoveNamespaceProcessor'|'XmlDumpProcessor'|'SelectWindowProcessor'|'AppendAggregateProcessor'|'ReplaceProcessor'|'CaseProcessor'|'TransformProcessor'|'SelectDistinctProcessor'|'InsertProcessor'|'LogProcessor'|'IndentProcessor'|'BreakPointProcessor'|'ExtractProcessor'}) [1]">
<ns1:XPath> ... </ns1:XPath> [0..1]
<ns1:namespaces> ... </ns1:namespaces> [0..1]
<ns1:variable> ... </ns1:variable> [0..*]
<ns1:parameter> ... </ns1:parameter> [0..*]
</ns1:processor>
Schema Component Representation
<xs:element name="processor" type=" ns1:processor "/>
top

Element: processors

Name processors
Type ns1:processors
Nillable no
Abstract no
XML Instance Representation
<ns1:processors>
Start Choice [0..*]
<ns1:repeat> ... </ns1:repeat> [1]
<ns1:element> ... </ns1:element> [1]
<ns1:elements> ... </ns1:elements> [1]
<ns1:element-ignore> ... </ns1:element-ignore> [1]
<ns1:element-create-as-parent> ... </ns1:element-create-as-parent> [1]
<ns2:e> ... </ns2:e> [1]
<ns1:processor> ... </ns1:processor> [1]
End Choice
</ns1:processors>
Schema Component Representation
<xs:element name="processors" type=" ns1:processors "/>
top

Element: processors-list

Name processors-list
Type ns1:postProcessorsList
Nillable no
Abstract no
XML Instance Representation
<ns1:processors-list>
<ns1:post-processors> ... </ns1:post-processors> [0..*]
</ns1:processors-list>
Schema Component Representation
<xs:element name="processors-list" type=" ns1:postProcessorsList "/>
top

Element: renderer

Name renderer
Type ns1:renderer
Nillable no
Abstract no
XML Instance Representation
<ns1:renderer
type=" xs:string (value comes from list: {'XMLRenderer'|'LDIFRenderer'|'CsvRenderer'|'GZipRenderer'|'ZipRenderer'|'TerminalRenderer'|'ExcelRenderer'|'DefaultRenderer'|'HTMLRenderer'|'JSONDeprecatedRenderer'|'HXMLRenderer'|'SQLRenderer'|'TextRenderer'|'RowColRenderer'|'ChartRenderer'|'ChartDeprecatedRenderer'|'JSONRenderer'|'JsonMLRenderer'|'PDFRenderer'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</ns1:renderer>
Schema Component Representation
<xs:element name="renderer" type=" ns1:renderer "/>
top

Element: renderers

Name renderers
Type ns1:renderers
Nillable no
Abstract no
XML Instance Representation
<ns1:renderers>
<ns1:renderer> ... </ns1:renderer> [0..*]
</ns1:renderers>
Schema Component Representation
<xs:element name="renderers" type=" ns1:renderers "/>
top

Element: repeat

Name repeat
Type tns:repeat
Nillable no
Abstract no
XML Instance Representation
<ns1:repeat> tns:repeat </ns1:repeat>
Schema Component Representation
<xs:element name="repeat" type=" tns:repeat "/>
top

Element: row

Name row
Type ns1:row
Nillable no
Abstract no
XML Instance Representation
<ns1:row
foreach=" xs:string [1]">
<ns1:column> ... </ns1:column> [1..*]
</ns1:row>
Schema Component Representation
<xs:element name="row" type=" ns1:row "/>
top

Element: serializer

Name serializer
Type ns1:serializer
Nillable no
Abstract no
XML Instance Representation
<ns1:serializer
type=" xs:string (value comes from list: {'ZipSerializer'|'DeprecatedTextSerializer'|'EncapsulateSerializer'|'CSVSerializer'|'ByteReplaceSerializer'|'GZipSerializer'|'SurroundSerializer'|'ListSerializer'|'PropertiesSerializer'|'StringReplaceSerializer'|'ByteEscapeSerializer'|'TextSerializer'|'LDIFSerializer'|'FixedWidthSerializer'|'HTMLSerializer'|'JSONStreamSerializer'|'JSONSerializer'|'YAMLSerializer'|'INISerializer'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</ns1:serializer>
Schema Component Representation
<xs:element name="serializer" type=" ns1:serializer "/>
top

Element: title

Name title
Type xs:string
Nillable no
Abstract no
XML Instance Representation
<ns1:title> xs:string </ns1:title>
Schema Component Representation
<xs:element name="title" type=" xs:string "/>
top

Element: trigger

Name trigger
Type ns1:trigger
Nillable no
Abstract no
XML Instance Representation
<ns1:trigger
ignore-during=" xs:duration [0..1]"
type=" xs:string (value comes from list: {'ViewNotifiedTrigger'|'CronTrigger'|'ViewCreatedTrigger'|'FixedTimeTrigger'|'DeltaTimeTrigger'|'ViewAccessedTrigger'|'DependencyRefreshedTrigger'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</ns1:trigger>
Schema Component Representation
<xs:element name="trigger" type=" ns1:trigger "/>
top

Element: validator

Name validator
Type ns1:validator
Nillable no
Abstract no
XML Instance Representation
<ns1:validator
disabled=" xs:string [0..1]"
type=" xs:string (value comes from list: {'SkeletonValidator'|'PathValidator'|'XSDValidator'|'RelaxNGValidator'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</ns1:validator>
Schema Component Representation
<xs:element name="validator" type=" ns1:validator "/>
top

Element: variable

Name variable
Type ns1:variable
Nillable no
Abstract no
XML Instance Representation
<ns1:variable
name=" xs:string [1]"
eval=" xs:string [0..1]">
ns1:xs:string
</ns1:variable>
Schema Component Representation
<xs:element name="variable" type=" ns1:variable "/>
top

Element: view

Name view
Type ns1:view
Nillable no
Abstract no
XML Instance Representation
<ns1:view
timeout=" xs:duration [0..1]"
authenticators=" xs:string [0..1]"
post-processors=" xs:string [0..1]"
name=" xs:ID [1]">
<ns1:namespace> ... </ns1:namespace> [0..*]
<ns1:info> ... </ns1:info> [0..1]
<ns1:argument> ... </ns1:argument> [0..*]
<ns1:variable> ... </ns1:variable> [0..*]
<ns1:connector> ... </ns1:connector> [1]
<ns1:serializer> ... </ns1:serializer> [0..1]
<ns1:validator> ... </ns1:validator> [0..1]
<ns1:processors> ... </ns1:processors> [0..1]
<ns1:cache> ... </ns1:cache> [0..1]
<ns1:pre-renderers> ... </ns1:pre-renderers> [0..1]
<ns1:renderers> ... </ns1:renderers> [0..1]
</ns1:view>
Schema Component Representation
<xs:element name="view" type=" ns1:view "/>
top

Element: views

Name views
Type ns1:configuration
Nillable no
Abstract no
XML Instance Representation
<ns1:views
name=" xs:ID [0..1]">
<ns1:view> ... </ns1:view> [0..*]
</ns1:views>
Schema Component Representation
<xs:element name="views" type=" ns1:configuration "/>
top

Global Definitions

Complex Type: abstractAdaptor

Super-types: abstractNode < abstractAdaptor (by extension)
Sub-types:
Name abstractAdaptor
Abstract yes
XML Instance Representation
<...>
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="abstractAdaptor" abstract="true">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:parameter " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: abstractContainer

Super-types: abstractNode < abstractContainer (by extension)
Sub-types:
Name abstractContainer
Abstract yes
XML Instance Representation
<.../>
Schema Component Representation
<xs:complexType name="abstractContainer" abstract="true">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: abstractNode

Super-types: None
Sub-types:
Name abstractNode
Abstract yes
XML Instance Representation
<.../>
Schema Component Representation
<xs:complexType name="abstractNode" abstract="true">
<xs:sequence/>
</xs:complexType>
top

Complex Type: abstractNodeWithPredicate

Super-types: None
Sub-types: None
Name abstractNodeWithPredicate
Abstract no
XML Instance Representation
<...
if=" xs:string [0..1]"/>
Schema Component Representation
<xs:complexType name="abstractNodeWithPredicate">
<xs:sequence/>
<xs:attribute name="if" type=" xs:string "/>
</xs:complexType>
top

Complex Type: abstractNodeWithValue

Super-types: ns1:xs:string < abstractNodeWithValue (by extension)
Sub-types: None
Name abstractNodeWithValue
Abstract no
XML Instance Representation
<...
if=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="abstractNodeWithValue">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="if" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: argument

Super-types: ns1:xs:string < argument (by extension)
Sub-types: None
Name argument
Abstract no
XML Instance Representation
<...
path-format=" pathFormat [0..1]"
name=" xs:string [1]"
eval=" xs:string [0..1]"
pattern=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="argument">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="path-format" type=" pathFormat "/>
<xs:attribute name="name" type=" xs:string " use="required"/>
<xs:attribute name="eval" type=" xs:string "/>
<xs:attribute name="pattern" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: attribute

Super-types: ns1:tns:abstractNodeWithValue < attribute (by extension)
Sub-types: None
Name attribute
Abstract no
XML Instance Representation
<...
in=" xs:QName [0..1]"
out=" xs:QName [0..1]"
from-element=" xs:boolean [0..1]">
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="attribute">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue ">
<xs:attribute name="in" type=" xs:QName "/>
<xs:attribute name="out" type=" xs:QName "/>
<xs:attribute name="from-element" type=" xs:boolean "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: attributeCreate

Super-types: ns1:tns:abstractNodeWithValue < attributeCreate (by extension)
Sub-types: None
Name attributeCreate
Abstract no
XML Instance Representation
<...
out=" xs:QName [1]">
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="attributeCreate">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue ">
<xs:attribute name="out" type=" xs:QName " use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: attributeIgnore

Super-types: ns1:tns:abstractNodeWithPredicate < attributeIgnore (by extension)
Sub-types: None
Name attributeIgnore
Abstract no
XML Instance Representation
<...
in=" xs:QName [0..1]"
from-element=" xs:boolean [0..1]">
<!-- ' ns1:tns:abstractNodeWithPredicate ' super type was not found in this schema. Some elements and attributes may be missing. -->
</...>
Schema Component Representation
<xs:complexType name="attributeIgnore">
<xs:complexContent>
<xs:extension base=" ns1:tns:abstractNodeWithPredicate ">
<xs:sequence/>
<xs:attribute name="in" type=" xs:QName "/>
<xs:attribute name="from-element" type=" xs:boolean "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: authenticator

Super-types: abstractNode < abstractAdaptor (by extension) < authenticator (by extension)
Sub-types: None
Name authenticator
Abstract no
XML Instance Representation
<...
authorized=" xs:string [0..1]"
type=" xs:string (value comes from list: {'X509Authenticator'|'CookieAuthenticator'|'KerberosHTMLFormAuthenticator'|'CASAuthenticator'|'WhiteListHTMLFormAuthenticator'|'KerberosHTTPBasicAuthenticator'|'OAuth2Authenticator'|'IPAddressAuthenticator'|'GuestAuthenticator'|'WhiteListHTTPBasicAuthenticator'|'SAML2Authenticator'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="authenticator">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence/>
<xs:attribute name="authorized" type=" xs:string "/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="X509Authenticator"/>
<xs:enumeration value="CookieAuthenticator"/>
<xs:enumeration value="KerberosHTMLFormAuthenticator"/>
<xs:enumeration value="CASAuthenticator"/>
<xs:enumeration value="WhiteListHTMLFormAuthenticator"/>
<xs:enumeration value="KerberosHTTPBasicAuthenticator"/>
<xs:enumeration value="OAuth2Authenticator"/>
<xs:enumeration value="IPAddressAuthenticator"/>
<xs:enumeration value="GuestAuthenticator"/>
<xs:enumeration value="WhiteListHTTPBasicAuthenticator"/>
<xs:enumeration value="SAML2Authenticator"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: authenticators

Super-types: abstractNode < abstractContainer (by extension) < authenticators (by extension)
Sub-types: None
Name authenticators
Abstract no
Documentation This section contains a chain of authenticators plug-ins
XML Instance Representation
<...
name=" xs:ID [0..1]">
<ns1:authenticator> ... </ns1:authenticator> [0..*]
</...>
Schema Component Representation
<xs:complexType name="authenticators">
<xs:complexContent>
<xs:extension base=" ns1:abstractContainer ">
<xs:sequence>
<xs:element ref=" ns1:authenticator " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="name" type=" xs:ID "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: authenticatorsList

Super-types: abstractNode < authenticatorsList (by extension)
Sub-types: None
Name authenticatorsList
Abstract no
XML Instance Representation
<...>
<ns1:authenticators> ... </ns1:authenticators> [0..*]
</...>
Schema Component Representation
<xs:complexType name="authenticatorsList">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:authenticators " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: cache

Super-types: abstractNode < abstractAdaptor (by extension) < cache (by extension)
Sub-types: None
Name cache
Abstract no
Documentation A cache saves the XML events stream in order to improve latency and/or availability
XML Instance Representation
<...
ttl=" xs:duration [0..1]"
exclusive=" xs:boolean [0..1]"
type=" xs:string (value comes from list: {'EmptyCache'|'MemoryCache'|'IndexedFileCache'|'FileCache'|'IndexedMemoryCache'|'BaseXCache'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
<ns1:trigger> ... </ns1:trigger> [1..*]
</...>
Schema Component Representation
<xs:complexType name="cache">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence>
<xs:element ref=" ns1:trigger " maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="ttl" type=" xs:duration "/>
<xs:attribute name="exclusive" type=" xs:boolean "/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="EmptyCache"/>
<xs:enumeration value="MemoryCache"/>
<xs:enumeration value="IndexedFileCache"/>
<xs:enumeration value="FileCache"/>
<xs:enumeration value="IndexedMemoryCache"/>
<xs:enumeration value="BaseXCache"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: column

Super-types: ns1:xs:string < column (by extension)
Sub-types: None
Name column
Abstract no
Documentation A column in the 2D-representation of the XML data view
XML Instance Representation
<...
hidden=" xs:boolean [0..1]"
unit=" xs:string [0..1]"
order=" sortDirection [0..1]"
link=" xs:string [0..1]"
label=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="column">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="hidden" type=" xs:boolean "/>
<xs:attribute name="unit" type=" xs:string "/>
<xs:attribute name="order" type=" sortDirection "/>
<xs:attribute name="link" type=" xs:string "/>
<xs:attribute name="label" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: comment

Super-types: ns1:tns:abstractNodeWithValue < comment (by extension)
Sub-types: None
Name comment
Abstract no
XML Instance Representation
<...>
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="comment">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue "/>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: commentCreate

Super-types: ns1:tns:abstractNodeWithValue < commentCreate (by extension)
Sub-types: None
Name commentCreate
Abstract no
XML Instance Representation
<...>
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="commentCreate">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue "/>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: commentIgnore

Super-types: ns1:tns:abstractNodeWithPredicate < commentIgnore (by extension)
Sub-types: None
Name commentIgnore
Abstract no
XML Instance Representation
<...>
<!-- ' ns1:tns:abstractNodeWithPredicate ' super type was not found in this schema. Some elements and attributes may be missing. -->
</...>
Schema Component Representation
<xs:complexType name="commentIgnore">
<xs:complexContent>
<xs:extension base=" ns1:tns:abstractNodeWithPredicate ">
<xs:sequence/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: configuration

Super-types: abstractNode < configuration (by extension)
Sub-types: None
Name configuration
Abstract no
Documentation This file contains the description of the XML data views managed by the Lavoisier framework
XML Instance Representation
<...
name=" xs:ID [0..1]">
<ns1:view> ... </ns1:view> [0..*]
</...>
Schema Component Representation
<xs:complexType name="configuration">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:view " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="name" type=" xs:ID "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: connector

Super-types: abstractNode < abstractAdaptor (by extension) < connector (by extension)
Sub-types: None
Name connector
Abstract no
Documentation A connector retrieves data from an external or an internal data source
XML Instance Representation
<...
type=" xs:string (value comes from list: {'IndexedFileCacheConnector'|'FileCacheConnector'|'IndexedMemoryCacheConnector'|'SynchronousCacheConnector'|'RotatingCacheConnector'|'MemoryCacheConnector'|'EmptyCacheConnector'|'BaseXCacheConnector'|'PublicKeyConnector'|'PathConnector'|'LDAPConnector'|'RTDPConnector'|'StandardInputConnector'|'SetSystemPropertyConnector'|'XMLConnector'|'MidiFileConnector'|'XSLTConnector'|'FileConnector'|'StringConnector'|'HTTPConnector'|'FileNotifiableConnector'|'ShellConnector'|'JMXOperationConnector'|'DirectoryConnector'|'JMXConnector'|'ConfigurationCheckingConnector'|'DiffConnector'|'JWTConnector'|'RemctlConnector'|'ScalaConnector'|'SQLConnector'|'XPath2SQLConnector'|'SFTPConnector'|'SSHExecConnector'|'TelnetConnector'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
<ns1:fallback> ... </ns1:fallback> [0..1]
</...>
Schema Component Representation
<xs:complexType name="connector">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence>
<xs:element ref=" ns1:fallback " minOccurs="0"/>
</xs:sequence>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="IndexedFileCacheConnector"/>
<xs:enumeration value="FileCacheConnector"/>
<xs:enumeration value="IndexedMemoryCacheConnector"/>
<xs:enumeration value="SynchronousCacheConnector"/>
<xs:enumeration value="RotatingCacheConnector"/>
<xs:enumeration value="MemoryCacheConnector"/>
<xs:enumeration value="EmptyCacheConnector"/>
<xs:enumeration value="BaseXCacheConnector"/>
<xs:enumeration value="PublicKeyConnector"/>
<xs:enumeration value="PathConnector"/>
<xs:enumeration value="LDAPConnector"/>
<xs:enumeration value="RTDPConnector"/>
<xs:enumeration value="StandardInputConnector"/>
<xs:enumeration value="SetSystemPropertyConnector"/>
<xs:enumeration value="XMLConnector"/>
<xs:enumeration value="MidiFileConnector"/>
<xs:enumeration value="XSLTConnector"/>
<xs:enumeration value="FileConnector"/>
<xs:enumeration value="StringConnector"/>
<xs:enumeration value="HTTPConnector"/>
<xs:enumeration value="FileNotifiableConnector"/>
<xs:enumeration value="ShellConnector"/>
<xs:enumeration value="JMXOperationConnector"/>
<xs:enumeration value="DirectoryConnector"/>
<xs:enumeration value="JMXConnector"/>
<xs:enumeration value="ConfigurationCheckingConnector"/>
<xs:enumeration value="DiffConnector"/>
<xs:enumeration value="JWTConnector"/>
<xs:enumeration value="RemctlConnector"/>
<xs:enumeration value="ScalaConnector"/>
<xs:enumeration value="SQLConnector"/>
<xs:enumeration value="XPath2SQLConnector"/>
<xs:enumeration value="SFTPConnector"/>
<xs:enumeration value="SSHExecConnector"/>
<xs:enumeration value="TelnetConnector"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: element

Super-types: ns1:tns:abstractNodeWithPredicate < element (by extension)
Sub-types: None
Name element
Abstract no
XML Instance Representation
<...
attributes=" xs:string [0..1]"
in=" xs:QName [0..1]"
out=" xs:QName [0..1]"
out-eval=" xs:string [0..1]"
future=" xs:boolean [0..1]"
namespace-ignore=" xs:boolean [0..1]"
recursive=" xs:boolean [0..1]"
flat=" xs:boolean [0..1]">
<!-- ' ns1:tns:abstractNodeWithPredicate ' super type was not found in this schema. Some elements and attributes may be missing. -->
<ns1:set> tns:set </ns1:set> [0..*]
Start Choice [0..*]
<ns1:attribute> tns:attribute </ns1:attribute> [1]
<ns1:attribute-create> tns:attributeCreate </ns1:attribute-create> [1]
<ns1:attribute-ignore> tns:attributeIgnore </ns1:attribute-ignore> [1]
End Choice
Start Choice [0..*]
<tns:element> ... </tns:element> [1]
<ns1:element-create> tns:elementCreate </ns1:element-create> [1]
<ns1:element-create-as-parent> tns:elementCreateAsParent </ns1:element-create-as-parent> [1]
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore> [1]
<ns1:element-recursive> tns:elementRecursive </ns1:element-recursive> [1]
<tns:elements> ... </tns:elements> [1]
<ns1:elements-ignore> tns:elementsIgnore </ns1:elements-ignore> [1]
<ns1:text> tns:text </ns1:text> [1]
<ns1:text-create> tns:textCreate </ns1:text-create> [1]
<ns1:text-ignore> tns:textIgnore </ns1:text-ignore> [1]
<ns1:comment> tns:comment </ns1:comment> [1]
<ns1:comment-create> tns:commentCreate </ns1:comment-create> [1]
<ns1:comment-ignore> tns:commentIgnore </ns1:comment-ignore> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="element">
<xs:complexContent>
<xs:extension base=" ns1:tns:abstractNodeWithPredicate ">
<xs:sequence>
<xs:element name="set" type=" tns:set " maxOccurs="unbounded" minOccurs="0"/>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element name="attribute" type=" tns:attribute "/>
<xs:element name="attribute-create" type=" tns:attributeCreate "/>
<xs:element name="attribute-ignore" type=" tns:attributeIgnore "/>
</xs:choice>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref=" tns:element "/>
<xs:element name="element-create" type=" tns:elementCreate "/>
<xs:element name="element-create-as-parent" type=" tns:elementCreateAsParent "/>
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
<xs:element name="element-recursive" type=" tns:elementRecursive "/>
<xs:element ref=" tns:elements "/>
<xs:element name="elements-ignore" type=" tns:elementsIgnore "/>
<xs:element name="text" type=" tns:text "/>
<xs:element name="text-create" type=" tns:textCreate "/>
<xs:element name="text-ignore" type=" tns:textIgnore "/>
<xs:element name="comment" type=" tns:comment "/>
<xs:element name="comment-create" type=" tns:commentCreate "/>
<xs:element name="comment-ignore" type=" tns:commentIgnore "/>
</xs:choice>
</xs:sequence>
<xs:attribute name="attributes" type=" xs:string "/>
<xs:attribute name="in" type=" xs:QName "/>
<xs:attribute name="out" type=" xs:QName "/>
<xs:attribute name="out-eval" type=" xs:string "/>
<xs:attribute name="future" type=" xs:boolean "/>
<xs:attribute name="namespace-ignore" type=" xs:boolean "/>
<xs:attribute name="recursive" type=" xs:boolean "/>
<xs:attribute name="flat" type=" xs:boolean "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: elementCreate

Super-types: ns1:tns:abstractNodeWithValue < elementCreate (by extension)
Sub-types: None
Name elementCreate
Abstract no
XML Instance Representation
<...
as=" tns:axis [0..1]">
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="elementCreate">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue ">
<xs:attribute name="as" type=" tns:axis "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: elementCreateAsParent

Super-types: None
Sub-types: None
Name elementCreateAsParent
Abstract no
XML Instance Representation
<...
attributes=" xs:string [0..1]"
group-by=" xs:string [0..1]"
out=" xs:QName [1]">
Start Choice [0..1]
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore> [1]
<tns:element> ... </tns:element> [1]
<ns1:text> tns:text </ns1:text> [1]
<ns1:comment> tns:comment </ns1:comment> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="elementCreateAsParent">
<xs:sequence>
<xs:choice minOccurs="0">
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
<xs:element ref=" tns:element "/>
<xs:element name="text" type=" tns:text "/>
<xs:element name="comment" type=" tns:comment "/>
</xs:choice>
</xs:sequence>
<xs:attribute name="attributes" type=" xs:string "/>
<xs:attribute name="group-by" type=" xs:string "/>
<xs:attribute name="out" type=" xs:QName " use="required"/>
</xs:complexType>
top

Complex Type: elementIgnore

Super-types: ns1:tns:abstractNodeWithPredicate < elementIgnore (by extension)
Sub-types: None
Name elementIgnore
Abstract no
XML Instance Representation
<...
in=" xs:QName [0..1]"
future=" xs:boolean [0..1]"
recursive=" xs:boolean [0..1]"
flat=" xs:boolean [0..1]">
<!-- ' ns1:tns:abstractNodeWithPredicate ' super type was not found in this schema. Some elements and attributes may be missing. -->
<ns1:set> tns:set </ns1:set> [0..*]
Start Choice [0..*]
<tns:element> ... </tns:element> [1]
<ns1:element-create> tns:elementCreate </ns1:element-create> [1]
<ns1:element-create-as-parent> tns:elementCreateAsParent </ns1:element-create-as-parent> [1]
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore> [1]
<ns1:element-recursive> tns:elementRecursive </ns1:element-recursive> [1]
<tns:elements> ... </tns:elements> [1]
<ns1:elements-ignore> tns:elementsIgnore </ns1:elements-ignore> [1]
<ns1:text> tns:text </ns1:text> [1]
<ns1:text-create> tns:textCreate </ns1:text-create> [1]
<ns1:text-ignore> tns:textIgnore </ns1:text-ignore> [1]
<ns1:comment> tns:comment </ns1:comment> [1]
<ns1:comment-create> tns:commentCreate </ns1:comment-create> [1]
<ns1:comment-ignore> tns:commentIgnore </ns1:comment-ignore> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="elementIgnore">
<xs:complexContent>
<xs:extension base=" ns1:tns:abstractNodeWithPredicate ">
<xs:sequence>
<xs:element name="set" type=" tns:set " maxOccurs="unbounded" minOccurs="0"/>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref=" tns:element "/>
<xs:element name="element-create" type=" tns:elementCreate "/>
<xs:element name="element-create-as-parent" type=" tns:elementCreateAsParent "/>
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
<xs:element name="element-recursive" type=" tns:elementRecursive "/>
<xs:element ref=" tns:elements "/>
<xs:element name="elements-ignore" type=" tns:elementsIgnore "/>
<xs:element name="text" type=" tns:text "/>
<xs:element name="text-create" type=" tns:textCreate "/>
<xs:element name="text-ignore" type=" tns:textIgnore "/>
<xs:element name="comment" type=" tns:comment "/>
<xs:element name="comment-create" type=" tns:commentCreate "/>
<xs:element name="comment-ignore" type=" tns:commentIgnore "/>
</xs:choice>
</xs:sequence>
<xs:attribute name="in" type=" xs:QName "/>
<xs:attribute name="future" type=" xs:boolean "/>
<xs:attribute name="recursive" type=" xs:boolean "/>
<xs:attribute name="flat" type=" xs:boolean "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: elementRecursive

Super-types: None
Sub-types: None
Name elementRecursive
Abstract no
XML Instance Representation
<...
count=" xs:int [1]"
ancestor=" xs:int [0..1]"/>
Schema Component Representation
<xs:complexType name="elementRecursive">
<xs:sequence/>
<xs:attribute name="count" type=" xs:int " use="required"/>
<xs:attribute name="ancestor" type=" xs:int "/>
</xs:complexType>
top

Complex Type: elements

Super-types: None
Sub-types: None
Name elements
Abstract no
XML Instance Representation
<...
attributes=" xs:string [0..1]"
path=" xs:string [1]">
<ns1:set> tns:set </ns1:set> [0..*]
Start Choice [0..*]
<ns1:attribute> tns:attribute </ns1:attribute> [1]
<ns1:attribute-create> tns:attributeCreate </ns1:attribute-create> [1]
<ns1:attribute-ignore> tns:attributeIgnore </ns1:attribute-ignore> [1]
End Choice
Start Choice [0..*]
<tns:element> ... </tns:element> [1]
<ns1:element-create> tns:elementCreate </ns1:element-create> [1]
<ns1:element-create-as-parent> tns:elementCreateAsParent </ns1:element-create-as-parent> [1]
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore> [1]
<ns1:element-recursive> tns:elementRecursive </ns1:element-recursive> [1]
<tns:elements> ... </tns:elements> [1]
<ns1:elements-ignore> tns:elementsIgnore </ns1:elements-ignore> [1]
<ns1:text> tns:text </ns1:text> [1]
<ns1:text-create> tns:textCreate </ns1:text-create> [1]
<ns1:text-ignore> tns:textIgnore </ns1:text-ignore> [1]
<ns1:comment> tns:comment </ns1:comment> [1]
<ns1:comment-create> tns:commentCreate </ns1:comment-create> [1]
<ns1:comment-ignore> tns:commentIgnore </ns1:comment-ignore> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="elements">
<xs:sequence>
<xs:element name="set" type=" tns:set " maxOccurs="unbounded" minOccurs="0"/>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element name="attribute" type=" tns:attribute "/>
<xs:element name="attribute-create" type=" tns:attributeCreate "/>
<xs:element name="attribute-ignore" type=" tns:attributeIgnore "/>
</xs:choice>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref=" tns:element "/>
<xs:element name="element-create" type=" tns:elementCreate "/>
<xs:element name="element-create-as-parent" type=" tns:elementCreateAsParent "/>
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
<xs:element name="element-recursive" type=" tns:elementRecursive "/>
<xs:element ref=" tns:elements "/>
<xs:element name="elements-ignore" type=" tns:elementsIgnore "/>
<xs:element name="text" type=" tns:text "/>
<xs:element name="text-create" type=" tns:textCreate "/>
<xs:element name="text-ignore" type=" tns:textIgnore "/>
<xs:element name="comment" type=" tns:comment "/>
<xs:element name="comment-create" type=" tns:commentCreate "/>
<xs:element name="comment-ignore" type=" tns:commentIgnore "/>
</xs:choice>
</xs:sequence>
<xs:attribute name="attributes" type=" xs:string "/>
<xs:attribute name="path" type=" xs:string " use="required"/>
</xs:complexType>
top

Complex Type: elementsIgnore

Super-types: None
Sub-types: None
Name elementsIgnore
Abstract no
XML Instance Representation
<...
path=" xs:string [1]">
<ns1:set> tns:set </ns1:set> [0..*]
Start Choice [0..*]
<ns1:attribute> tns:attribute </ns1:attribute> [1]
<ns1:attribute-create> tns:attributeCreate </ns1:attribute-create> [1]
<ns1:attribute-ignore> tns:attributeIgnore </ns1:attribute-ignore> [1]
End Choice
Start Choice [0..*]
<tns:element> ... </tns:element> [1]
<ns1:element-create> tns:elementCreate </ns1:element-create> [1]
<ns1:element-create-as-parent> tns:elementCreateAsParent </ns1:element-create-as-parent> [1]
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore> [1]
<ns1:element-recursive> tns:elementRecursive </ns1:element-recursive> [1]
<tns:elements> ... </tns:elements> [1]
<ns1:elements-ignore> tns:elementsIgnore </ns1:elements-ignore> [1]
<ns1:text> tns:text </ns1:text> [1]
<ns1:text-create> tns:textCreate </ns1:text-create> [1]
<ns1:text-ignore> tns:textIgnore </ns1:text-ignore> [1]
<ns1:comment> tns:comment </ns1:comment> [1]
<ns1:comment-create> tns:commentCreate </ns1:comment-create> [1]
<ns1:comment-ignore> tns:commentIgnore </ns1:comment-ignore> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="elementsIgnore">
<xs:sequence>
<xs:element name="set" type=" tns:set " maxOccurs="unbounded" minOccurs="0"/>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element name="attribute" type=" tns:attribute "/>
<xs:element name="attribute-create" type=" tns:attributeCreate "/>
<xs:element name="attribute-ignore" type=" tns:attributeIgnore "/>
</xs:choice>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref=" tns:element "/>
<xs:element name="element-create" type=" tns:elementCreate "/>
<xs:element name="element-create-as-parent" type=" tns:elementCreateAsParent "/>
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
<xs:element name="element-recursive" type=" tns:elementRecursive "/>
<xs:element ref=" tns:elements "/>
<xs:element name="elements-ignore" type=" tns:elementsIgnore "/>
<xs:element name="text" type=" tns:text "/>
<xs:element name="text-create" type=" tns:textCreate "/>
<xs:element name="text-ignore" type=" tns:textIgnore "/>
<xs:element name="comment" type=" tns:comment "/>
<xs:element name="comment-create" type=" tns:commentCreate "/>
<xs:element name="comment-ignore" type=" tns:commentIgnore "/>
</xs:choice>
</xs:sequence>
<xs:attribute name="path" type=" xs:string " use="required"/>
</xs:complexType>
top

Complex Type: entry

Super-types: ns1:xs:string < entry (by extension)
Sub-types: None
Name entry
Abstract no
Documentation An entry of the list/map parameter
XML Instance Representation
<...
key=" xs:string [0..1]"
eval=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="entry">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="key" type=" xs:string "/>
<xs:attribute name="eval" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: exception

Super-types: None
Sub-types: None
Name exception
Abstract no
XML Instance Representation
<...
type=" xs:string [1]"
predicate-on-message=" xs:string [0..1]"/>
Schema Component Representation
<xs:complexType name="exception">
<xs:sequence/>
<xs:attribute name="type" type=" xs:string " use="required"/>
<xs:attribute name="predicate-on-message" type=" xs:string "/>
</xs:complexType>
top

Complex Type: fallback

Super-types: abstractNode < fallback (by extension)
Sub-types: None
Name fallback
Abstract no
XML Instance Representation
<...
eval=" xs:string [0..1]">
<ns1:exception> ... </ns1:exception> [1..*]
</...>
Schema Component Representation
<xs:complexType name="fallback">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:exception " maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="eval" type=" xs:string "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: field

Super-types: ns1:xs:string < field (by extension)
Sub-types: None
Name field
Abstract no
Documentation The template for the header fields of the 2D-representation of the XML data view
XML Instance Representation
<...
label=" xs:string [0..1]"
link=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="field">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="label" type=" xs:string "/>
<xs:attribute name="link" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: info

Super-types: abstractNode < info (by extension)
Sub-types: None
Name info
Abstract no
Documentation Information about the view
XML Instance Representation
<...>
Allow any elements from any namespace (skip validation). [0..*]
</...>
Schema Component Representation
<xs:complexType name="info">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:any maxOccurs="unbounded" minOccurs="0" namespace="##any" processContents="skip"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: namespace

Super-types: abstractNode < namespace (by extension)
Sub-types: None
Name namespace
Abstract no
Documentation The namespace prefix to namespace URI mapping
XML Instance Representation
<...
uri=" xs:string [1]"
prefix=" xs:string [1]"/>
Schema Component Representation
<xs:complexType name="namespace">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence/>
<xs:attribute name="uri" type=" xs:string " use="required"/>
<xs:attribute name="prefix" type=" xs:string " use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: namespaces

Super-types: abstractNode < namespaces (by extension)
Sub-types: None
Name namespaces
Abstract no
XML Instance Representation
<...
eval=" xs:string [0..1]">
<ns1:entry> ... </ns1:entry> [0..*]
</...>
Schema Component Representation
<xs:complexType name="namespaces">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:entry " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="eval" type=" xs:string "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: parameter

Super-types: None
Sub-types: None
Name parameter
Abstract no
Documentation A parameter of the plug-in must have a name (among those supported by the plug-in) and a value. This value can be fixed (by using attribute 'value') or dynamically evaluated (by using attribute 'eval'). When the parameter type is a list or a map, then its entries can be set by using child elements &lt;entry&gt;.
XML Instance Representation
<...
name=" xs:string [1] ?"
eval=" xs:string [0..1]">
<!-- Mixed content -->
<ns1:entry> ... </ns1:entry> [0..*]
Start Choice [0..*]
End Choice
</...>
Schema Component Representation
<xs:complexType name="parameter" mixed="true">
<xs:sequence>
<xs:element ref=" ns1:entry " maxOccurs="unbounded" minOccurs="0"/>
<xs:choice maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="name" type=" xs:string " use="required"/>
<xs:attribute name="eval" type=" xs:string "/>
</xs:complexType>
top

Complex Type: postProcessors

Super-types: abstractNode < abstractContainer (by extension) < processors (by extension) < postProcessors (by extension)
Sub-types: None
Name postProcessors
Abstract no
Documentation This section contains a chain of processor plug-ins
XML Instance Representation
<...
name=" xs:ID [0..1]">
Start Choice [0..*]
<ns1:repeat> ... </ns1:repeat> [1]
<ns1:element> ... </ns1:element> [1]
<ns1:elements> ... </ns1:elements> [1]
<ns1:element-ignore> ... </ns1:element-ignore> [1]
<ns1:element-create-as-parent> ... </ns1:element-create-as-parent> [1]
<ns2:e> ... </ns2:e> [1]
<ns1:processor> ... </ns1:processor> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="postProcessors">
<xs:complexContent>
<xs:extension base=" ns1:processors ">
<xs:sequence/>
<xs:attribute name="name" type=" xs:ID "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: postProcessorsList

Super-types: abstractNode < postProcessorsList (by extension)
Sub-types: None
Name postProcessorsList
Abstract no
XML Instance Representation
<...>
<ns1:post-processors> ... </ns1:post-processors> [0..*]
</...>
Schema Component Representation
<xs:complexType name="postProcessorsList">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:post-processors " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: preprocessor

Super-types: None
Sub-types: None
Name preprocessor
Abstract no
XML Instance Representation
<.../>
Schema Component Representation
<xs:complexType name="preprocessor">
<xs:sequence/>
</xs:complexType>
top

Complex Type: preRenderers

Super-types: abstractNode < preRenderers (by extension)
Sub-types: None
Name preRenderers
Abstract no
Documentation This section describes how to convert the data view into a two-dimensional representation, for renderers that need such a representation
XML Instance Representation
<...
row-column=" xs:string [0..1]">
<ns1:namespace> ... </ns1:namespace> [0..*]
<ns1:title> ... </ns1:title> [0..1]
<ns1:field> ... </ns1:field> [0..*]
<ns1:row> ... </ns1:row> [1]
</...>
Schema Component Representation
<xs:complexType name="preRenderers">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:namespace " maxOccurs="unbounded" minOccurs="0"/>
<xs:element ref=" ns1:title " minOccurs="0"/>
<xs:element ref=" ns1:field " maxOccurs="unbounded" minOccurs="0"/>
<xs:element ref=" ns1:row "/>
</xs:sequence>
<xs:attribute name="row-column" type=" xs:string "/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: processor

Super-types: abstractNode < processor (by extension)
Sub-types: None
Name processor
Abstract no
Documentation A processor transforms a XML events stream to a new XML events stream
XML Instance Representation
<...
match=" xs:string [1]"
disabled=" xs:string [0..1]"
type=" xs:string (value comes from list: {'XPathValidatorProcessor'|'MergeProcessor'|'MultiMergeProcessor'|'SelectAncestorProcessor'|'CopyProcessor'|'SelectGroupByProcessor'|'RenameWithXPathProcessor'|'SkeletonProcessor'|'EncodeProcessor'|'TemplateGeneratorProcessor'|'RenameProcessor'|'CDATAProcessor'|'MoveProcessor'|'LimitProcessor'|'InsertParentProcessor'|'SelectProcessor'|'RemoveHeaderProcessor'|'EventListBuilderProcessor'|'ChangeNamespaceProcessor'|'RemoveProcessor'|'ElementToAttributeProcessor'|'RemoveNamespaceProcessor'|'XmlDumpProcessor'|'SelectWindowProcessor'|'AppendAggregateProcessor'|'ReplaceProcessor'|'CaseProcessor'|'TransformProcessor'|'SelectDistinctProcessor'|'InsertProcessor'|'LogProcessor'|'IndentProcessor'|'BreakPointProcessor'|'ExtractProcessor'}) [1]">
<ns1:XPath> ... </ns1:XPath> [0..1]
<ns1:namespaces> ... </ns1:namespaces> [0..1]
<ns1:variable> ... </ns1:variable> [0..*]
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="processor">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:XPath " minOccurs="0"/>
<xs:element ref=" ns1:namespaces " minOccurs="0"/>
<xs:element ref=" ns1:variable " maxOccurs="unbounded" minOccurs="0"/>
<xs:element ref=" ns1:parameter " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="match" type=" xs:string " use="required"/>
<xs:attribute name="disabled" type=" xs:string "/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="XPathValidatorProcessor"/>
<xs:enumeration value="MergeProcessor"/>
<xs:enumeration value="MultiMergeProcessor"/>
<xs:enumeration value="SelectAncestorProcessor"/>
<xs:enumeration value="CopyProcessor"/>
<xs:enumeration value="SelectGroupByProcessor"/>
<xs:enumeration value="RenameWithXPathProcessor"/>
<xs:enumeration value="SkeletonProcessor"/>
<xs:enumeration value="EncodeProcessor"/>
<xs:enumeration value="TemplateGeneratorProcessor"/>
<xs:enumeration value="RenameProcessor"/>
<xs:enumeration value="CDATAProcessor"/>
<xs:enumeration value="MoveProcessor"/>
<xs:enumeration value="LimitProcessor"/>
<xs:enumeration value="InsertParentProcessor"/>
<xs:enumeration value="SelectProcessor"/>
<xs:enumeration value="RemoveHeaderProcessor"/>
<xs:enumeration value="EventListBuilderProcessor"/>
<xs:enumeration value="ChangeNamespaceProcessor"/>
<xs:enumeration value="RemoveProcessor"/>
<xs:enumeration value="ElementToAttributeProcessor"/>
<xs:enumeration value="RemoveNamespaceProcessor"/>
<xs:enumeration value="XmlDumpProcessor"/>
<xs:enumeration value="SelectWindowProcessor"/>
<xs:enumeration value="AppendAggregateProcessor"/>
<xs:enumeration value="ReplaceProcessor"/>
<xs:enumeration value="CaseProcessor"/>
<xs:enumeration value="TransformProcessor"/>
<xs:enumeration value="SelectDistinctProcessor"/>
<xs:enumeration value="InsertProcessor"/>
<xs:enumeration value="LogProcessor"/>
<xs:enumeration value="IndentProcessor"/>
<xs:enumeration value="BreakPointProcessor"/>
<xs:enumeration value="ExtractProcessor"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: processors

Super-types: abstractNode < abstractContainer (by extension) < processors (by extension)
Sub-types:
Name processors
Abstract no
Documentation This section contains a chain of processor plug-ins
XML Instance Representation
<...>
Start Choice [0..*]
<ns1:repeat> ... </ns1:repeat> [1]
<ns1:element> ... </ns1:element> [1]
<ns1:elements> ... </ns1:elements> [1]
<ns1:element-ignore> ... </ns1:element-ignore> [1]
<ns1:element-create-as-parent> ... </ns1:element-create-as-parent> [1]
<ns2:e> ... </ns2:e> [1]
<ns1:processor> ... </ns1:processor> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="processors">
<xs:complexContent>
<xs:extension base=" ns1:abstractContainer ">
<xs:sequence>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref=" ns1:repeat "/>
<xs:element ref=" ns1:element "/>
<xs:element ref=" ns1:elements "/>
<xs:element ref=" ns1:element-ignore "/>
<xs:element ref=" ns1:element-create-as-parent "/>
<xs:element ref=" ns2:e "/>
<xs:element ref=" ns1:processor "/>
</xs:choice>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: renderer

Super-types: abstractNode < abstractAdaptor (by extension) < renderer (by extension)
Sub-types: None
Name renderer
Abstract no
Documentation A renderer transforms a XML events stream to a bytes stream in the format requested by user
XML Instance Representation
<...
type=" xs:string (value comes from list: {'XMLRenderer'|'LDIFRenderer'|'CsvRenderer'|'GZipRenderer'|'ZipRenderer'|'TerminalRenderer'|'ExcelRenderer'|'DefaultRenderer'|'HTMLRenderer'|'JSONDeprecatedRenderer'|'HXMLRenderer'|'SQLRenderer'|'TextRenderer'|'RowColRenderer'|'ChartRenderer'|'ChartDeprecatedRenderer'|'JSONRenderer'|'JsonMLRenderer'|'PDFRenderer'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="renderer">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="XMLRenderer"/>
<xs:enumeration value="LDIFRenderer"/>
<xs:enumeration value="CsvRenderer"/>
<xs:enumeration value="GZipRenderer"/>
<xs:enumeration value="ZipRenderer"/>
<xs:enumeration value="TerminalRenderer"/>
<xs:enumeration value="ExcelRenderer"/>
<xs:enumeration value="DefaultRenderer"/>
<xs:enumeration value="HTMLRenderer"/>
<xs:enumeration value="JSONDeprecatedRenderer"/>
<xs:enumeration value="HXMLRenderer"/>
<xs:enumeration value="SQLRenderer"/>
<xs:enumeration value="TextRenderer"/>
<xs:enumeration value="RowColRenderer"/>
<xs:enumeration value="ChartRenderer"/>
<xs:enumeration value="ChartDeprecatedRenderer"/>
<xs:enumeration value="JSONRenderer"/>
<xs:enumeration value="JsonMLRenderer"/>
<xs:enumeration value="PDFRenderer"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: renderers

Super-types: abstractNode < abstractContainer (by extension) < renderers (by extension)
Sub-types: None
Name renderers
Abstract no
Documentation This section enables modifying the default configuration of renderer, but it has no impact on which renderer will be chosen by users (all the renderers are always available to users).
XML Instance Representation
<...>
<ns1:renderer> ... </ns1:renderer> [0..*]
</...>
Schema Component Representation
<xs:complexType name="renderers">
<xs:complexContent>
<xs:extension base=" ns1:abstractContainer ">
<xs:sequence>
<xs:element ref=" ns1:renderer " maxOccurs="unbounded" minOccurs="0"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: renderingStylesheetFactory

Super-types: None
Sub-types: None
Name renderingStylesheetFactory
Abstract no
XML Instance Representation
<.../>
Schema Component Representation
<xs:complexType name="renderingStylesheetFactory">
<xs:sequence/>
</xs:complexType>
top

Complex Type: repeat

Super-types: None
Sub-types: None
Name repeat
Abstract no
XML Instance Representation
<...
count=" xs:string [1]">
Start Choice [0..*]
<tns:element> ... </tns:element> [1]
<tns:elements> ... </tns:elements> [1]
<ns1:element-ignore> tns:elementIgnore </ns1:element-ignore> [1]
End Choice
</...>
Schema Component Representation
<xs:complexType name="repeat">
<xs:sequence>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref=" tns:element "/>
<xs:element ref=" tns:elements "/>
<xs:element name="element-ignore" type=" tns:elementIgnore "/>
</xs:choice>
</xs:sequence>
<xs:attribute name="count" type=" xs:string " use="required"/>
</xs:complexType>
top

Complex Type: row

Super-types: abstractNode < row (by extension)
Sub-types: None
Name row
Abstract no
Documentation The template for the 2D-representation of the XML data view
XML Instance Representation
<...
foreach=" xs:string [1]">
<ns1:column> ... </ns1:column> [1..*]
</...>
Schema Component Representation
<xs:complexType name="row">
<xs:complexContent>
<xs:extension base=" ns1:abstractNode ">
<xs:sequence>
<xs:element ref=" ns1:column " maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="foreach" type=" xs:string " use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: scala

Super-types: abstractNode < abstractContainer (by extension) < scala (by extension)
Sub-types: None
Name scala
Abstract no
XML Instance Representation
<...
_=" xs:ID [1]"
Allow any attributes from any namespace (skip validation).
>
Allow any elements from any namespace (skip validation). [1]
</...>
Schema Component Representation
<xs:complexType name="scala">
<xs:complexContent>
<xs:extension base=" ns1:abstractContainer ">
<xs:sequence>
<xs:any namespace="##any" processContents="skip"/>
</xs:sequence>
<xs:attribute name="_" type=" xs:ID " use="required"/>
<xs:anyAttribute namespace="##any" processContents="skip"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: serializer

Super-types: abstractNode < abstractAdaptor (by extension) < serializer (by extension)
Sub-types: None
Name serializer
Abstract no
Documentation A serializer transforms a bytes stream to a XML events stream
XML Instance Representation
<...
type=" xs:string (value comes from list: {'ZipSerializer'|'DeprecatedTextSerializer'|'EncapsulateSerializer'|'CSVSerializer'|'ByteReplaceSerializer'|'GZipSerializer'|'SurroundSerializer'|'ListSerializer'|'PropertiesSerializer'|'StringReplaceSerializer'|'ByteEscapeSerializer'|'TextSerializer'|'LDIFSerializer'|'FixedWidthSerializer'|'HTMLSerializer'|'JSONStreamSerializer'|'JSONSerializer'|'YAMLSerializer'|'INISerializer'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="serializer">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="ZipSerializer"/>
<xs:enumeration value="DeprecatedTextSerializer"/>
<xs:enumeration value="EncapsulateSerializer"/>
<xs:enumeration value="CSVSerializer"/>
<xs:enumeration value="ByteReplaceSerializer"/>
<xs:enumeration value="GZipSerializer"/>
<xs:enumeration value="SurroundSerializer"/>
<xs:enumeration value="ListSerializer"/>
<xs:enumeration value="PropertiesSerializer"/>
<xs:enumeration value="StringReplaceSerializer"/>
<xs:enumeration value="ByteEscapeSerializer"/>
<xs:enumeration value="TextSerializer"/>
<xs:enumeration value="LDIFSerializer"/>
<xs:enumeration value="FixedWidthSerializer"/>
<xs:enumeration value="HTMLSerializer"/>
<xs:enumeration value="JSONStreamSerializer"/>
<xs:enumeration value="JSONSerializer"/>
<xs:enumeration value="YAMLSerializer"/>
<xs:enumeration value="INISerializer"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: set

Super-types: ns1:xs:string < set (by extension)
Sub-types: None
Name set
Abstract no
XML Instance Representation
<...
variable=" xs:string [1]"
index=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="set">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="variable" type=" xs:string " use="required"/>
<xs:attribute name="index" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: text

Super-types: ns1:tns:abstractNodeWithValue < text (by extension)
Sub-types: None
Name text
Abstract no
XML Instance Representation
<...>
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="text">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue "/>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: textCreate

Super-types: ns1:tns:abstractNodeWithValue < textCreate (by extension)
Sub-types: None
Name textCreate
Abstract no
XML Instance Representation
<...>
ns1:tns:abstractNodeWithValue
</...>
Schema Component Representation
<xs:complexType name="textCreate">
<xs:simpleContent>
<xs:extension base=" ns1:tns:abstractNodeWithValue "/>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: textIgnore

Super-types: ns1:tns:abstractNodeWithPredicate < textIgnore (by extension)
Sub-types: None
Name textIgnore
Abstract no
XML Instance Representation
<...>
<!-- ' ns1:tns:abstractNodeWithPredicate ' super type was not found in this schema. Some elements and attributes may be missing. -->
</...>
Schema Component Representation
<xs:complexType name="textIgnore">
<xs:complexContent>
<xs:extension base=" ns1:tns:abstractNodeWithPredicate ">
<xs:sequence/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: trigger

Super-types: abstractNode < abstractAdaptor (by extension) < trigger (by extension)
Sub-types: None
Name trigger
Abstract no
Documentation A rule for triggering cache refresh
XML Instance Representation
<...
ignore-during=" xs:duration [0..1]"
type=" xs:string (value comes from list: {'ViewNotifiedTrigger'|'CronTrigger'|'ViewCreatedTrigger'|'FixedTimeTrigger'|'DeltaTimeTrigger'|'ViewAccessedTrigger'|'DependencyRefreshedTrigger'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="trigger">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence/>
<xs:attribute name="ignore-during" type=" xs:duration "/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="ViewNotifiedTrigger"/>
<xs:enumeration value="CronTrigger"/>
<xs:enumeration value="ViewCreatedTrigger"/>
<xs:enumeration value="FixedTimeTrigger"/>
<xs:enumeration value="DeltaTimeTrigger"/>
<xs:enumeration value="ViewAccessedTrigger"/>
<xs:enumeration value="DependencyRefreshedTrigger"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: validator

Super-types: abstractNode < abstractAdaptor (by extension) < validator (by extension)
Sub-types: None
Name validator
Abstract no
XML Instance Representation
<...
disabled=" xs:string [0..1]"
type=" xs:string (value comes from list: {'SkeletonValidator'|'PathValidator'|'XSDValidator'|'RelaxNGValidator'}) [1]">
<ns1:parameter> ... </ns1:parameter> [0..*]
</...>
Schema Component Representation
<xs:complexType name="validator">
<xs:complexContent>
<xs:extension base=" ns1:abstractAdaptor ">
<xs:sequence/>
<xs:attribute name="disabled" type=" xs:string "/>
<xs:attribute name="type" use="required">
<xs:simpleType>
<xs:restriction base=" xs:string ">
<xs:enumeration value="SkeletonValidator"/>
<xs:enumeration value="PathValidator"/>
<xs:enumeration value="XSDValidator"/>
<xs:enumeration value="RelaxNGValidator"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: variable

Super-types: ns1:xs:string < variable (by extension)
Sub-types: None
Name variable
Abstract no
XML Instance Representation
<...
name=" xs:string [1]"
eval=" xs:string [0..1]">
ns1:xs:string
</...>
Schema Component Representation
<xs:complexType name="variable">
<xs:simpleContent>
<xs:extension base=" ns1:xs:string ">
<xs:attribute name="name" type=" xs:string " use="required"/>
<xs:attribute name="eval" type=" xs:string "/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
top

Complex Type: view

Super-types: abstractNode < abstractContainer (by extension) < view (by extension)
Sub-types: None
Name view
Abstract no
Documentation A XML data view
XML Instance Representation
<...
timeout=" xs:duration [0..1]"
authenticators=" xs:string [0..1]"
post-processors=" xs:string [0..1]"
name=" xs:ID [1]">
<ns1:namespace> ... </ns1:namespace> [0..*]
<ns1:info> ... </ns1:info> [0..1]
<ns1:argument> ... </ns1:argument> [0..*]
<ns1:variable> ... </ns1:variable> [0..*]
<ns1:connector> ... </ns1:connector> [1]
<ns1:serializer> ... </ns1:serializer> [0..1]
<ns1:validator> ... </ns1:validator> [0..1]
<ns1:processors> ... </ns1:processors> [0..1]
<ns1:cache> ... </ns1:cache> [0..1]
<ns1:pre-renderers> ... </ns1:pre-renderers> [0..1]
<ns1:renderers> ... </ns1:renderers> [0..1]
</...>
Schema Component Representation
<xs:complexType name="view">
<xs:complexContent>
<xs:extension base=" ns1:abstractContainer ">
<xs:sequence>
<xs:element ref=" ns1:namespace " maxOccurs="unbounded" minOccurs="0"/>
<xs:element ref=" ns1:info " minOccurs="0"/>
<xs:element ref=" ns1:argument " maxOccurs="unbounded" minOccurs="0"/>
<xs:element ref=" ns1:variable " maxOccurs="unbounded" minOccurs="0"/>
<xs:element ref=" ns1:connector "/>
<xs:element ref=" ns1:serializer " minOccurs="0"/>
<xs:element ref=" ns1:validator " minOccurs="0"/>
<xs:element ref=" ns1:processors " minOccurs="0"/>
<xs:element ref=" ns1:cache " minOccurs="0"/>
<xs:element ref=" ns1:pre-renderers " minOccurs="0"/>
<xs:element ref=" ns1:renderers " minOccurs="0"/>
</xs:sequence>
<xs:attribute name="timeout" type=" xs:duration "/>
<xs:attribute name="authenticators" type=" xs:string "/>
<xs:attribute name="post-processors" type=" xs:string "/>
<xs:attribute name="name" type=" xs:ID " use="required"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
top

Complex Type: xPath

Super-types: None
Sub-types: None
Name xPath
Abstract no
Documentation *************************************************** *** Centre de Calcul de l'IN2P3 - Lyon (France) *** *** http://cc.in2p3.fr/ *** *************************************************** File: xpath Author: Sylvain Reynaud (sreynaud@in2p3.fr) ***************************************************

Prevent JAXB from generating beans for descendants of element <XPath/>
XML Instance Representation
<...>
Allow any elements from any namespace (skip validation). [0..*]
</...>
Schema Component Representation
<xs:complexType name="xPath">
<xs:sequence>
<xs:any maxOccurs="unbounded" minOccurs="0" namespace="##any" processContents="skip"/>
</xs:sequence>
</xs:complexType>
top

Simple Type: axis

Super-types: xs:string < axis (by restriction)
Sub-types: None
Name axis
Content
  • Base XSD Type: string
  • value comes from list: {'following-sibling'|'preceding-sibling'|'last-child'|'first-child'}
Documentation Accepted values are: following-sibling, preceding-sibling, last-child, first-child
Schema Component Representation
<xs:simpleType name="axis">
<xs:restriction base=" xs:string ">
<xs:enumeration value="following-sibling"/>
<xs:enumeration value="preceding-sibling"/>
<xs:enumeration value="last-child"/>
<xs:enumeration value="first-child"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: pathFormat

Super-types: xs:string < pathFormat (by restriction)
Sub-types: None
Name pathFormat
Content
  • Base XSD Type: string
  • value comes from list: {'value'|'none'|'name_value'}
Documentation Accepted values are: value, none, name_value
Schema Component Representation
<xs:simpleType name="pathFormat">
<xs:restriction base=" xs:string ">
<xs:enumeration value="value"/>
<xs:enumeration value="none"/>
<xs:enumeration value="name_value"/>
</xs:restriction>
</xs:simpleType>
top

Simple Type: sortDirection

Super-types: xs:string < sortDirection (by restriction)
Sub-types: None
Name sortDirection
Content
  • Base XSD Type: string
  • value comes from list: {'descending'|'ascending'}
Documentation Accepted values are: descending, ascending
Schema Component Representation
<xs:simpleType name="sortDirection">
<xs:restriction base=" xs:string ">
<xs:enumeration value="descending"/>
<xs:enumeration value="ascending"/>
</xs:restriction>
</xs:simpleType>
top

Legend

Complex Type:

Schema Component Type

AusAddress

Schema Component Name
Super-types: Address < AusAddress (by extension)
Sub-types:
  • QLDAddress (by restriction)
If this schema component is a type definition, its type hierarchy is shown in a gray-bordered box.
Name AusAddress
Abstract no
The table above displays the properties of this schema component.
XML Instance Representation
<... country="Australia" >
<unitNo> string </unitNo> [0..1]
<houseNo> string </houseNo> [1]
<street> string </street> [1]
Start Choice [1]
<city> string </city> [1]
<town> string </town> [1]
End Choice
<state> AusStates </state> [1]
<postcode> string <<pattern = [1-9][0-9]{3}>> </postcode> [1] ?
</...>

The XML Instance Representation table above shows the schema component's content as an XML instance.

Schema Component Representation
<complexType name="AusAddress">
<complexContent>
<extension base=" Address ">
<sequence>
<element name="state" type=" AusStates "/>
<element name="postcode">
<simpleType>
<restriction base=" string ">
<pattern value="[1-9][0-9]{3}"/>
</restriction>
</simpleType>
</element>
</sequence>
<attribute name="country" type=" string " fixed="Australia"/>
</extension>
</complexContent>
</complexType>
The Schema Component Representation table above displays the underlying XML representation of the schema component. (Annotations are not shown.)
top

Glossary

Abstract (Applies to complex type definitions and element declarations). An abstract element or complex type cannot used to validate an element instance. If there is a reference to an abstract element, only element declarations that can substitute the abstract element can be used to validate the instance. For references to abstract type definitions, only derived types can be used.

All Model Group Child elements can be provided in any order in instances. See: http://www.w3.org/TR/xmlschema-1/#element-all.

Choice Model Group Only one from the list of child elements and model groups can be provided in instances. See: http://www.w3.org/TR/xmlschema-1/#element-choice.

Collapse Whitespace Policy Replace tab, line feed, and carriage return characters with space character (Unicode character 32). Then, collapse contiguous sequences of space characters into single space character, and remove leading and trailing space characters.

Disallowed Substitutions (Applies to element declarations). If substitution is specified, then substitution group members cannot be used in place of the given element declaration to validate element instances. If derivation methods, e.g. extension, restriction, are specified, then the given element declaration will not validate element instances that have types derived from the element declaration's type using the specified derivation methods. Normally, element instances can override their declaration's type by specifying an xsi:type attribute.

Key Constraint Like Uniqueness Constraint, but additionally requires that the specified value(s) must be provided. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

Key Reference Constraint Ensures that the specified value(s) must match value(s) from a Key Constraint or Uniqueness Constraint. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

Model Group Groups together element content, specifying the order in which the element content can occur and the number of times the group of element content may be repeated. See: http://www.w3.org/TR/xmlschema-1/#Model_Groups.

Nillable (Applies to element declarations). If an element declaration is nillable, instances can use the xsi:nil attribute. The xsi:nil attribute is the boolean attribute, nil, from the http://www.w3.org/2001/XMLSchema-instance namespace. If an element instance has an xsi:nil attribute set to true, it can be left empty, even though its element declaration may have required content.

Notation A notation is used to identify the format of a piece of data. Values of elements and attributes that are of type, NOTATION, must come from the names of declared notations. See: http://www.w3.org/TR/xmlschema-1/#cNotation_Declarations.

Preserve Whitespace Policy Preserve whitespaces exactly as they appear in instances.

Prohibited Derivations (Applies to type definitions). Derivation methods that cannot be used to create sub-types from a given type definition.

Prohibited Substitutions (Applies to complex type definitions). Prevents sub-types that have been derived using the specified derivation methods from validating element instances in place of the given type definition.

Replace Whitespace Policy Replace tab, line feed, and carriage return characters with space character (Unicode character 32).

Sequence Model Group Child elements and model groups must be provided in the specified order in instances. See: http://www.w3.org/TR/xmlschema-1/#element-sequence.

Substitution Group Elements that are members of a substitution group can be used wherever the head element of the substitution group is referenced.

Substitution Group Exclusions (Applies to element declarations). Prohibits element declarations from nominating themselves as being able to substitute a given element declaration, if they have types that are derived from the original element's type using the specified derivation methods.

Target Namespace The target namespace identifies the namespace that components in this schema belongs to. If no target namespace is provided, then the schema components do not belong to any namespace.

Uniqueness Constraint Ensures uniqueness of an element/attribute value, or a combination of values, within a specified scope. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

top

Generated by xs3p (old link) . Last modified: