ilscipio/scipio-erp

View on GitHub
framework/widget/dtd/widget-common.xsd

Summary

Maintainability
Test Coverage
<?xml version="1.0" encoding="UTF-8"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
    <!--
        DEV NOTE: TODO: REVIEW: This file has been manually duplicated in:
            widget-form.xsd
            widget-menu.xsd
            widget-screen.xsd
            widget-tree.xsd
        Changes made here may need to be duplicated there.
        This allows for more reliable IDE integration, simplified XML parsing for libraries, and support for per-file modifications.
    -->
    <xs:annotation>
        <xs:documentation><![CDATA[
            Common Widget Definitions
        
            SCIPIO: In Scipio, the common widget language is modified from stock Ofbiz with new elements and
            modifications to existing elements. The renderer is modified accordingly, and it may have yet
            additional changes not visible through the language elements alone (may be noted here).
            Changes are prefixed with the string "SCIPIO:" in annotations and comments.
            
            Features and Modifications (including but not limited to):
            * link element boolean attributes full-path/secure/encode no longer hardcode defaults (instead centralized in java),
              and the meaning, behavior and default behavior of those parameters is ratified for safer and more intuitive use.
              Reflects @ofbizUrl changes in Freemarker templates and java RequestHandler.makeLink changes.
              (see @ofbizUrl entry in utilities.ftl - component://common/webcommon/includes/scipio/lib/utilities.ftl;
              see makeLink and makeLinkAuto methods in RequestHandler.java - org.ofbiz.webapp.control.RequestHandler)
            * script element is enhanced for full inline script body support (based on simple-methods-v2)
            * New dedicated actions include directives - include-xxx-actions - notably include-screen-actions,
              which is shorter and more appropriate way to include actions defined in separate screens.
            * New master "if" actions directive available (based on simple-methods-v2), which is
              easier and more appropriate for actions-only conditions than the section conditions element
            * if-true/if-false conditional shorthand for booleans and string repr. of booleans
            * if-widget conditional for testing presence of widget definitions
            
            To use this and other widget XML schema definition files (*.xsd) in your development environment for autocompletion and validation,
            import the file named ".xmlcatalog.xml" from the Scipio project root as XML Catalog file/project type using import dialog.
            Note this also includes the definition files for all other Scipio/ofbiz XML resources such as entity models, service defs, etc.
        ]]></xs:documentation>
    </xs:annotation>
    <xs:complexType name="ConditionRootType">
        <xs:choice>
            <xs:element ref="and" />
            <xs:element ref="or" />
            <xs:element ref="xor" />
            <xs:element ref="not" />
            <xs:element ref="if-service-permission" />
            <xs:element ref="if-has-permission" />
            <xs:element ref="if-entity-permission" />
            <xs:element ref="if-validate-method" />
            <xs:element ref="if-compare" />
            <xs:element ref="if-compare-field" />
            <xs:element ref="if-regexp" />
            <xs:element ref="if-empty" />
            <xs:element ref="if-true" /><!-- SCIPIO: 2016-11-09: new -->
            <xs:element ref="if-false" /><!-- SCIPIO: 2016-11-09: new -->
            <xs:element ref="if-widget" /><!-- SCIPIO: 2016-11-11: new -->
            <xs:element ref="if-component" /><!-- SCIPIO: 2018-12-11: new -->
            <xs:element ref="if-entity" /><!-- SCIPIO: 2018-12-11: new -->
            <xs:element ref="if-service" /><!-- SCIPIO: 2018-12-11: new -->
        </xs:choice>
    </xs:complexType>
    <xs:element name="AllConditionals" abstract="true" />
    <xs:element name="and" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="AllConditionals" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="xor" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="AllConditionals" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="or" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" ref="AllConditionals" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="not" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="AllConditionals" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="if-service-permission" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:attribute type="xs:string" name="service-name" use="required" />
            <xs:attribute type="xs:string" name="resource-description" use="optional" />
            <xs:attribute type="xs:string" name="context-map" use="optional" />
            <xs:attribute name="main-action" use="optional">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="ADMIN"/><!-- SCIPIO: 2018-05-24: allow direct test for ADMIN -->
                        <xs:enumeration value="CREATE" />
                        <xs:enumeration value="UPDATE" />
                        <xs:enumeration value="DELETE" />
                        <xs:enumeration value="VIEW" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="if-has-permission" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:attribute type="xs:string" name="permission" use="required" />
            <xs:attribute type="xs:string" name="action" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-entity-permission" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:choice minOccurs="0">
                <xs:element minOccurs="0" maxOccurs="1" ref="permission-condition-getter" />
                <xs:element minOccurs="0" maxOccurs="1" ref="related-role-getter" />
                <xs:element minOccurs="0" maxOccurs="1" ref="auxiliary-value-getter" />
            </xs:choice>
            <xs:attribute type="xs:string" name="entity-name" use="required" />
            <xs:attribute type="xs:string" name="entity-id" use="required">
                <xs:annotation>
                    <xs:documentation>Can have multiple pipe separated values, but don't use spaces.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute type="xs:string" name="target-operation" use="required">
                <xs:annotation>
                    <xs:documentation>Can have multiple pipe separated values, but don't use spaces.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="display-fail-cond" type="xs:boolean"
                          default="false"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="permission-condition-getter">
        <xs:complexType>
            <xs:attribute type="xs:string" name="entity-name" />
            <xs:attribute type="xs:string" name="operation-field-name" />
            <xs:attribute type="xs:string" name="role-field-name" />
            <xs:attribute type="xs:string" name="auxiliary-field-name" />
            <xs:attribute type="xs:string" name="status-field-name" />
            <xs:attribute type="xs:string" name="privilege-field-name" />
        </xs:complexType>
    </xs:element>
    <xs:element name="related-role-getter">
        <xs:complexType>
            <xs:attribute type="xs:string" name="entity-name" />
            <xs:attribute type="xs:string" name="role-entity-name" />
            <xs:attribute type="xs:string" name="role-type-field-name" />
            <xs:attribute type="xs:string" name="party-field-name" />
            <xs:attribute type="xs:string" name="owner-entity-field-name" />
            <xs:attribute type="xs:string" name="entity-id-name" />
        </xs:complexType>
    </xs:element>
    <xs:element name="auxiliary-value-getter">
        <xs:complexType>
            <xs:attribute type="xs:string" name="entity-name" />
            <xs:attribute type="xs:string" name="auxiliary-field-name" />
            <xs:attribute type="xs:string" name="entity-id-name" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-validate-method" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>Calls a static Java method that takes a
            String and returns a boolean.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
            <xs:attribute type="xs:string" name="method" use="required" />
            <xs:attribute type="xs:string" name="class" default="org.ofbiz.base.util.UtilValidate" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-compare" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:attribute name="field" type="xs:string" use="required" />
            <xs:attribute name="operator" use="required">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="less" />
                        <xs:enumeration value="greater" />
                        <xs:enumeration value="less-equals" />
                        <xs:enumeration value="greater-equals" />
                        <xs:enumeration value="equals" />
                        <xs:enumeration value="not-equals" />
                        <xs:enumeration value="contains" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="value" type="xs:string" use="required" />
            <xs:attribute name="type" default="String">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PlainString" />
                        <xs:enumeration value="String" />
                        <xs:enumeration value="BigDecimal" />
                        <xs:enumeration value="Double" />
                        <xs:enumeration value="Float" />
                        <xs:enumeration value="Long" />
                        <xs:enumeration value="Integer" />
                        <xs:enumeration value="Date" />
                        <xs:enumeration value="Time" />
                        <xs:enumeration value="Timestamp" />
                        <xs:enumeration value="Boolean" />
                        <xs:enumeration value="Object" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute type="xs:string" name="format" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-compare-field" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:attribute name="field" type="xs:string" use="required" />
            <xs:attribute name="operator" use="required">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="less" />
                        <xs:enumeration value="greater" />
                        <xs:enumeration value="less-equals" />
                        <xs:enumeration value="greater-equals" />
                        <xs:enumeration value="equals" />
                        <xs:enumeration value="not-equals" />
                        <xs:enumeration value="contains" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="to-field" type="xs:string" />
            <xs:attribute name="type" default="String">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PlainString" />
                        <xs:enumeration value="String" />
                        <xs:enumeration value="BigDecimal" />
                        <xs:enumeration value="Double" />
                        <xs:enumeration value="Float" />
                        <xs:enumeration value="Long" />
                        <xs:enumeration value="Integer" />
                        <xs:enumeration value="Date" />
                        <xs:enumeration value="Time" />
                        <xs:enumeration value="Timestamp" />
                        <xs:enumeration value="Boolean" />
                        <xs:enumeration value="Object" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute type="xs:string" name="format" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-regexp" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
            <xs:attribute type="xs:string" name="expr" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-empty" substitutionGroup="AllConditionals">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-true" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>SCIPIO: Evaluates to true if and only if the field is Boolean true
                OR the string value "true" (case-sensitive).
                Either field or value must be provided.
                2016-11-09: New element, added for 1.14.3.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" />
            <xs:attribute type="xs:string" name="value" />
            <xs:attribute name="verify" type="xs:boolean" default="true">
                <xs:annotation>
                    <xs:documentation>If true, and the test does not pass, the check will additionally 
                        verify the failing expression to make sure it is a valid negative response and
                        print a log error upon failure.
                        Default: true</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="allow-empty" type="xs:boolean" default="true">
                <xs:annotation>
                    <xs:documentation>If true, the field type verification check will accept empty or null as valid.
                        Default: true
                        NOTE: This only affects logging/exception handling. It does not affect whether
                            this condition returns true or false.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="if-false" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>SCIPIO: Evaluates to true if and only if the field is Boolean false
                OR the string value "false" (case-sensitive).
                2016-11-09: New element, added for 1.14.3.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" />
            <xs:attribute type="xs:string" name="value" />
            <xs:attribute name="verify" type="xs:boolean" default="true">
                <xs:annotation>
                    <xs:documentation>If true, and the test does not pass, the check will additionally 
                        verify the failing expression to make sure it is a valid negative response and
                        print a log error upon failure.
                        Default: true</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="allow-empty" type="xs:boolean" default="true">
                <xs:annotation>
                    <xs:documentation>If true, the field type verification check will accept empty or null as valid.
                        Default: true
                        NOTE: This only affects logging/exception handling. It does not affect whether
                            this condition returns true or false.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="if-widget" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>SCIPIO: Verifies a screen/form/menu widget.
                For example, "defined" operation checks if exists at the given location.
                Name/location support flexible expressions.
                2016-11-11: New element, added for 1.14.3.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="name" use="required"/>
            <xs:attribute type="xs:string" name="location" use="required"/>
            <xs:attribute name="type" use="required">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="screen" />
                        <xs:enumeration value="form" />
                        <xs:enumeration value="menu" />
                        <xs:enumeration value="tree" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="operator" use="required">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="defined" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="if-component" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>SCIPIO: Returns true if the given component exists and is enabled.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="component-name" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-entity" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>SCIPIO: Returns true if the given entity exists.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="entity-name" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if-service" substitutionGroup="AllConditionals">
        <xs:annotation>
            <xs:documentation>SCIPIO: Returns true if the given service exists.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="service-name" use="required" />
        </xs:complexType>
    </xs:element>

    <xs:element name="AllActions" abstract="true" />
    <xs:element name="set" substitutionGroup="AllActions">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
            <xs:attribute type="xs:string" name="from-field" />
            <xs:attribute type="xs:string" name="value" />
            <xs:attribute type="xs:string" name="default-value" />
            <xs:attribute name="global" type="xs:boolean" default="false"/>
            <xs:attribute name="type">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PlainString" />
                        <xs:enumeration value="String" />
                        <xs:enumeration value="BigDecimal" />
                        <xs:enumeration value="Double" />
                        <xs:enumeration value="Float" />
                        <xs:enumeration value="List" />
                        <xs:enumeration value="Long" />
                        <xs:enumeration value="Integer" />
                        <xs:enumeration value="Date" />
                        <xs:enumeration value="Time" />
                        <xs:enumeration value="Timestamp" />
                        <xs:enumeration value="Boolean" />
                        <xs:enumeration value="Object" />
                        <xs:enumeration value="NewList" />
                        <xs:enumeration value="NewMap" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="to-scope" default="screen">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="screen" />
                        <xs:enumeration value="user" />
                        <xs:enumeration value="application" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="from-scope" default="screen">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="screen" />
                        <xs:enumeration value="user" />
                        <xs:enumeration value="application" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="set-if-empty" type="xs:boolean" default="true">
                <xs:annotation>
                    <xs:documentation>
                        Controls if the target field can be set to an empty value. The meaning of "empty" depends on the Java data type.
                        Defaults to "true".
                        Optional.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="set-if-null" type="xs:boolean" default="true">
                <xs:annotation>
                    <xs:documentation>
                        Controls if the target field can be set to null when the from attribute evaluates to null.
                        Defaults to "true".
                        Optional.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="clear-field" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>
                SCIPIO: Sets the specified field to null.
                This is the same as the simple-methods*.xsd language clear-field.
                Added 2019-02-04.
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="property-map" substitutionGroup="AllActions">
        <xs:complexType>
            <xs:attribute type="xs:string" name="resource" use="required" />
            <xs:attribute type="xs:string" name="map-name" use="required" />
            <xs:attribute name="global" type="xs:boolean" default="false"/>
            <xs:attribute name="optional" type="xs:boolean" default="false">
                <xs:annotation>
                    <xs:documentation>
                        SCIPIO: If set to true, missing property-map will not generate an error.
                        NOTE: You may need to restart the system or clear various caches to see the effect of changing this flag.
                        Added 2018-11-29.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="property-to-field" substitutionGroup="AllActions">
        <xs:complexType>
            <xs:attribute type="xs:string" name="resource" use="required" />
            <xs:attribute type="xs:string" name="property" use="required" />
            <xs:attribute type="xs:string" name="field" use="required" />
            <xs:attribute type="xs:string" name="default" />
            <xs:attribute name="no-locale" type="xs:boolean" default="false"/>
            <xs:attribute type="xs:string" name="arg-list-name" />
        </xs:complexType>
    </xs:element>
    <xs:element name="script" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>Runs an external script and/or a short inline script (scriptlet). The scriptlet can be
                included in the script attribute or in the element body.
                
                SCIPIO: This element's functionality has been extended using the simple-methods-v2 minilang implementation of
                the element of the same name, to provide inline script functionality, as either child CDATA text or via "script" attribute.
                For inline scripts, a script language (groovy, etc.) must be specified, either using the explicit lang attribute (new in Scipio)
                or by prefixing to the script body followed by colon (no leading spaces; stock ofbiz syntax).
                
                PARSING BEHAVIOR: The child CDATA text of this element is NOT parsed for special operators, 
                    UNLIKE the simple-methods-v2 version and unlike the further "script" attribute described below.
                    The intent of this difference is to avoid adulterating larger scripts in any way whatsoever.
                    The simple-methods-v2 version of this element pre-parses the child text of its script element and
                    this prevents inline scripts from perfectly emulating separate files.
                    
                2016-11-11: Enhanced for 1.14.3.</xs:documentation>
        </xs:annotation>
        <xs:complexType mixed="true">
            <xs:attribute name="lang">
                <xs:annotation>
                    <xs:documentation>SCIPIO: Script language, explicit.
                        Optional for scripts specified by location (extension is used instead; NOTE: 2016-11-11: lang attribute may be ignored for location).
                        Required for scripts inlined as child CDATA text script body or script attribute
                        IF the language name is not otherwise prefixed to the script body followed by colon (with no leading space, e.g. "groovy:...").
                        Unless succinctness has priority, it is preferable to specify this attribute rather than prefix
                        as it is less error-prone (prefix is space-sensitive) and supports xml editor completion.
                        Default: (none)
                        RECOMMENDED: groovy</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="groovy" />
                        <xs:enumeration value="simple-method" />
                        <xs:enumeration value="simple-map-processor" />
                        <!-- SCIPIO: 2018-09-19: Since this attribute was added for Scipio, likely nobody used this, so can let xml parser report as error
                        <xs:enumeration value="bsh">
                            <xs:annotation>
                                <xs:documentation>
                                    SCIPIO: 2018-09-19: DEPRECATED: Please change your code to groovy instead.
                                    Beanshell is no longer supported and this directive now runs Groovy in a compatibility mode.
                                </xs:documentation>
                            </xs:annotation>
                        </xs:enumeration>-->
                        <!-- SCIPIO: 2018-09-19: This was never used, and it's certain it cannot work
                            anymore; unclear if it ever had a chance of working or could in future
                        <xs:enumeration value="java" />-->
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute type="xs:string" name="location"><!-- SCIPIO: no longer strictly required: use="required" -->
                <xs:annotation>
                    <xs:documentation>The script location. The location attribute accepts the component:// file location
                        protocol. Script functions/methods can be invoked by appending a hash (#) and the
                        function/method name.
                        
                        Required if the script attribute and script element body (child CDATA text) are empty.
                        
                        SCIPIO: This is a STOCK attribute, but it has been enhanced to support flexible expressions, 
                        evaluated at runtime.
                        WARN: The screens that parametrize script locations and/or names are responsible for using
                            only safe variables (DO NOT use the parameters map).
                        Enhanced for 1.14.2.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute type="xs:string" name="script">
                <xs:annotation>
                    <xs:documentation><![CDATA[
                        A short script (scriptlet). Can be used instead of a file.
                        The script must be prefixed with the script language followed by a colon (":"), with no leading spaces,
                        OR (new in Scipio) the language may be specified in the explicit lang attribute.
                        
                        Required if the location attribute is empty and there is no script body as child CDATA text. Attribute type: script.
                        
                        SCIPIO: This attribute and script inlining is borrowed from minilang simple-methods-v2 for use in screens directives.
                        In Scipio, the main draw is inlining script body as child CDATA text and this attribute is the alternative.
                        NOTE: This script attribute - but NOT the script body if specified as child CDATA text - is subject to
                            pre-parsing for special keyword operator substitutions (as done by simple-methods-v2 in stock ofbiz): 
                              @and, @or, @lteq, @gteq, @lt, @gt 
                            These are translated to, respectively:
                              &&, ||, <=, >=, <, >
                            See org.ofbiz.base.util.StringUtil.convertOperatorSubstitutions for detailed behavior.
                        NOTE: The context preparation and behavior of this scriptlet behaves slightly differently than that of scripts
                            inlined into flexible expressions (FlexibleStringExpander) in other attributes.
                            This one behaves analogous to the dedicated script files when specified by location, unlike the inline
                            scripts in those flexible expressions (this is part reason for the enhancement of the script element in Scipio).
                        2016-11-11: Added for 1.14.3.
                    ]]></xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute type="xs:boolean" name="trim-lines" default="true">
                <xs:annotation>
                    <xs:documentation>SCIPIO: If true, perform trim on every line of child CDATA text to remove excess whitespace from XML.
                        NOTE: This gets rid of indents, but flattens code.
                        NOTE: If set to false, may affect performance due to the script caching mechanism (keyed on script body).
                        Default: true (to optimize caching speed)</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="entity-one" substitutionGroup="AllActions">
        <xs:complexType>
            <xs:sequence>
                <xs:element minOccurs="0" maxOccurs="unbounded" ref="field-map" />
                <xs:element minOccurs="0" maxOccurs="unbounded" ref="select-field" />
            </xs:sequence>
            <xs:attribute name="entity-name" type="xs:string" use="required" />
            <xs:attribute name="value-field" type="xs:string"><!-- SCIPIO: 2018-04-14: was never required: use="required" -->
                <xs:annotation>
                    <xs:documentation>
                        Name of a context field to store the resulting entity value;
                        if omitted, the entity's fields are dumped into the current context.
                        
                        SCIPIO: NOTE: This attribute was marked as required in stock ofbiz,
                        but it always worked fine without it and behaved as described here.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="use-cache" type="xs:boolean" default="false"/>
            <xs:attribute name="auto-field-map" type="xs:boolean" default="true"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="get-related-one" substitutionGroup="AllActions">
        <xs:complexType>
            <xs:attribute name="value-field" type="xs:string" use="required" />
            <xs:attribute name="relation-name" type="xs:string" use="required" />
            <xs:attribute name="use-cache" type="xs:string" default="false" />
            <xs:attribute name="to-value-field" type="xs:string" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="get-related" substitutionGroup="AllActions">
        <xs:complexType>
            <xs:attribute type="xs:string" name="value-field" use="required" />
            <xs:attribute type="xs:string" name="relation-name" use="required" />
            <xs:attribute type="xs:string" name="map" />
            <xs:attribute type="xs:string" name="order-by-list" />
            <xs:attribute type="xs:string" name="use-cache" default="false" />
            <xs:attribute type="xs:string" name="list" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="include-screen-actions" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Includes a screen's top section actions in this widget's actions where the directive appears.
                Name and location support flexible expressions and are resolved at runtime.
                NOTE: This ignores and bypasses the named screen's condition element.
                NOTE: This directive includes the actions from the fully-built target widget model (rather than textually), with full recursion implied
                    but ONLY with respect to other include-screen-actions directives;
                    this will NOT include actions that would be run as a result of the widgets-element-based include-screen directive.
                    In other words, the screens referenced with this directive should strive to use solely directives under the
                    actions element, and even omit the other top directives entirely for clarity.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="name" use="required"/>
            <xs:attribute type="xs:string" name="location" />
        </xs:complexType>
    </xs:element>
    <xs:element name="include-form-actions" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Includes a form's top section actions in this widget's actions where the directive appears.
                NOTE: This directive includes the actions from the fully-built target widget model (not textually), with full recursion implied.
                    name and location support flexible expressions and are resolved at runtime.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="name" use="required"/>
            <xs:attribute type="xs:string" name="location" />
        </xs:complexType>
    </xs:element>
    <xs:element name="include-form-row-actions" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Includes a form's top section row-actions in this widget's actions where the directive appears.
                NOTE: This directive includes the actions from the fully-built target widget model (not textually), with full recursion implied.
                    name and location support flexible expressions and are resolved at runtime.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="name" use="required"/>
            <xs:attribute type="xs:string" name="location" />
        </xs:complexType>
    </xs:element>
    <xs:element name="include-menu-actions" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Includes a menu's top section actions in this widget's actions where the directive appears.
                NOTE: This directive includes the actions from the fully-built target widget model (not textually), with full recursion implied.
                    name and location support flexible expressions and are resolved at runtime.
                NOTE: Not to be confused with the static/build-time include-actions directive available as child of menu/sub-menu elements from widget-menu.xsd.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="name" use="required"/>
            <xs:attribute type="xs:string" name="location" />
        </xs:complexType>
    </xs:element>
    <xs:element name="include-tree-actions" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Includes a tree's top section actions in this widget's actions where the directive appears.
                NOTE: This directive includes the actions from the fully-built target widget model (not textually), with full recursion implied.
                    name and location support flexible expressions and are resolved at runtime.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="name" use="required"/>
            <xs:attribute type="xs:string" name="location" />
        </xs:complexType>
    </xs:element>
    <xs:element name="condition-list">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="condition-expr" />
                <xs:element ref="condition-list" />
                <xs:element ref="condition-object" />
            </xs:choice>
            <xs:attribute name="combine" default="and">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="and" />
                        <xs:enumeration value="or" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="having-condition-list">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element ref="condition-expr" />
                <xs:element ref="condition-list" />
                <xs:element ref="condition-object" />
            </xs:choice>
            <xs:attribute name="combine" default="and">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="and" />
                        <xs:enumeration value="or" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="condition-expr">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field-name" use="required" />
            <xs:attribute name="operator" default="equals">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="less" />
                        <xs:enumeration value="greater" />
                        <xs:enumeration value="less-equals" />
                        <xs:enumeration value="greater-equals" />
                        <xs:enumeration value="equals" />
                        <xs:enumeration value="not-equals" />
                        <xs:enumeration value="in" />
                        <xs:enumeration value="not-in" />
                        <xs:enumeration value="between" />
                        <xs:enumeration value="like" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute type="xs:string" name="from-field" />
            <xs:attribute type="xs:string" name="value" />
            <xs:attribute name="ignore-if-null" type="xs:boolean" default="false"/>
            <xs:attribute name="ignore-if-empty" type="xs:boolean" default="false"/>
            <xs:attribute name="ignore-case" type="xs:boolean" default="false"/>
            <xs:attribute name="ignore" type="xs:boolean" default="false">
                <xs:annotation>
                    <xs:documentation>
                        Ignore the condition if flag is true.
                        Defaults to false.
                    </xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="condition-object">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="select-field">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field-name" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="order-by">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field-name" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="limit-range">
        <xs:complexType>
            <xs:attribute name="start" type="xs:string" use="required">
                <xs:annotation>
                    <xs:documentation>Should resolve into a non-negative integer.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="size" type="xs:string" use="required">
                <xs:annotation>
                    <xs:documentation>Should resolve into a non-negative integer.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="limit-view">
        <xs:complexType>
            <xs:attribute name="view-index" type="xs:string" use="required">
                <xs:annotation>
                    <xs:documentation>Should resolve into a non-negative integer.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="view-size" type="xs:string" use="required">
                <xs:annotation>
                    <xs:documentation>Should resolve into a positive integer.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="use-iterator" />
    <xs:element name="field-map">
        <xs:complexType>
            <xs:attribute type="xs:string" name="field-name" use="required" />
            <xs:attribute type="xs:string" name="from-field" />
            <xs:attribute type="xs:string" name="value" />
        </xs:complexType>
    </xs:element>
    <xs:element name="parameter">
        <xs:complexType>
            <xs:attribute type="xs:string" name="param-name" use="required" />
            <xs:attribute type="xs:string" name="from-field" />
            <xs:attribute type="xs:string" name="value" />
        </xs:complexType>
    </xs:element>
    <xs:element name="auto-parameters-service">
        <xs:complexType>
            <xs:sequence>
                <xs:element minOccurs="0" maxOccurs="unbounded" ref="exclude" />
            </xs:sequence>
            <xs:attribute name="service-name" type="xs:string">
                <xs:annotation>
                    <xs:documentation>The service name used to resolve parameters. If empty, use form defaultServiceName. Flexible string allowed.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="send-if-empty" type="xs:boolean" default="true"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="auto-parameters-entity">
        <xs:complexType>
            <xs:sequence>
                <xs:element minOccurs="0" maxOccurs="unbounded" ref="exclude" />
            </xs:sequence>
            <xs:attribute name="entity-name" type="xs:string">
                <xs:annotation>
                    <xs:documentation>The entity name used to resolve parameters. If empty use form defaultEntityName attribute. Flexible string allowed.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="include" default="pk">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="pk" />
                        <xs:enumeration value="nonpk" />
                        <xs:enumeration value="all" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="send-if-empty" type="xs:boolean" default="true"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="parameter-map">
        <xs:annotation>
            <xs:documentation>SCIPIO: Designates a field containing a map whose entries to use as parameters.
                2017-09-21: New in Scipio; added for 1.14.4.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute name="from-field" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Name of field which should contain a map whose entries will be used as parameters.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="exclude">
        <xs:complexType>
            <xs:attribute name="field-name" type="xs:string" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:complexType name="link">
        <xs:sequence>
            <xs:element minOccurs="0" ref="auto-parameters-service"/>
            <xs:element minOccurs="0" ref="auto-parameters-entity"/>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="parameter-map" /><!-- SCIPIO: added 2017-09-21 -->
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="parameter" />
            <xs:element minOccurs="0" name="image" type="image" />
        </xs:sequence>
        <xs:attribute type="xs:string" name="text" />
        <xs:attribute type="xs:string" name="id">
            <xs:annotation>
                <xs:documentation>
                    If you use id for link present in list form or multi form, you can use ${itemIndex} to generate an unique id by line.
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute type="xs:string" name="style" />
        <xs:attribute type="xs:string" name="name" />
        <xs:attribute type="xs:string" name="title" />
        <xs:attribute type="xs:nonNegativeInteger" name="size" /><!-- Text size limit -->
        <xs:attribute type="xs:string" name="target">
            <xs:annotation>
                <xs:documentation>
                    Link target (href).
                    SCIPIO: 2016-10-21: enhanced: if url-mode is "inter-app" and target ends with exactly the string
                    "#extLoginKey=OFF", then no external login key is added, and the 
                    "#extLoginKey=OFF" string is stripped. It must be the last part of the string to work (ends with).
                </xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute type="xs:string" name="target-window" />
        <xs:attribute type="xs:string" name="prefix" />
        <xs:attribute type="xs:string" name="width" />
        <xs:attribute type="xs:string" name="height" />
        <xs:attribute name="link-type" default="auto">
            <xs:simpleType>
                <xs:restriction base="xs:token">
                    <xs:enumeration value="auto">
                        <xs:annotation>
                            <xs:documentation>
                                If selected the hidden-form type will be used if the url-mode is intra-app
                                and the request specified has an event, otherwise the anchor type will be used,
                                except if the ajax-window or layered-modal mode is specified.
                            </xs:documentation>
                        </xs:annotation>
                    </xs:enumeration>
                    <xs:enumeration value="anchor" />
                    <xs:enumeration value="hidden-form" />
                    <!-- FIXME: This is not a link type. It indicates the target window should be a popup dialog. -->
                    <xs:enumeration value="ajax-window" />
                    <xs:enumeration value="layered-modal">
                        <xs:annotation>
                            <xs:documentation>
                                SCIPIO: WARN: 2018-09-04: This link type is
                                not fully supported at this time. Merged 2018-09-04.
                            </xs:documentation>
                        </xs:annotation>
                    </xs:enumeration>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="url-mode" default="intra-app">
            <xs:simpleType>
                <xs:restriction base="xs:token">
                    <xs:enumeration value="intra-app" />
                    <xs:enumeration value="inter-app" />
                    <xs:enumeration value="content" />
                    <xs:enumeration value="plain" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="full-path" type="xs:boolean"/><!-- SCIPIO: default removed - default is null: default="false" -->
        <xs:attribute name="secure" type="xs:boolean"/><!-- SCIPIO: default removed - default is null: default="false" -->
        <xs:attribute name="encode" type="xs:boolean"/><!-- SCIPIO: default removed - default is null (should be true, not false!): default="false" -->
        <xs:attribute name="request-confirmation" type="xs:boolean"
                      default="false">
            <xs:annotation>
                <xs:documentation>If true then the user is presented with a dialog box, if confirmation-message is empty, use default
                    SCIPIO: TODO: Currently only implemented for certain types of links (hyperlink)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute type="xs:string" name="confirmation-message">
            <xs:annotation>
                <xs:documentation>The message displayed in confirmation box
                    SCIPIO: TODO: Currently only implemented for certain types of links (hyperlink)</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute type="xs:string" name="use-when">
            <xs:annotation>
                <xs:documentation>SCIPIO: A condition whose result should evaluate to true/false to determine
                    when the link should be applied to the text. In gneeral, expressions should be specified using
                    flexible expressions syntax: ${...}, ${groovy:...}, etc.
                    NOTE: Some specific link sub-types may also fallback to plain Groovy expressions (without ${...} written),
                        but this is currently inconsistent (e.g. form widget sub-hyperlink has it).
                    NOTE: Currently (2016-09-12), this is only used directly by menu widgets.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="image" mixed="true">
        <xs:attribute type="xs:string" name="src" />
        <xs:attribute type="xs:string" name="id" />
        <xs:attribute type="xs:string" name="style" />
        <xs:attribute type="xs:string" name="width" />
        <xs:attribute type="xs:string" name="height" />
        <xs:attribute type="xs:string" name="border" />
        <xs:attribute type="xs:string" name="alt" />
        <xs:attribute type="xs:string" name="title" />
        <xs:attribute name="url-mode" default="content">
            <xs:simpleType>
                <xs:restriction base="xs:token">
                    <xs:enumeration value="ofbiz" />
                    <xs:enumeration value="content" />
                    <xs:enumeration value="raw" />
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:complexType>
    <xs:element name="condition-to-field" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Evaluates children condition elements and sets a field based on the boolean result. 
                By default, and for String/PlainString types, this returns a string having the value "true"/"false" (String type is for consistency with set operation); 
                if Boolean type explicitly specified, returns proper Boolean true/false; 
                special "Indicator" type returns "Y"/"N" as string;
                all others return null by default and values can be specified through pass-value/fail-value attributes.
                2016-11-09: New in Scipio; added for 1.14.3.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element minOccurs="1" maxOccurs="unbounded" ref="AllConditionals" />
            </xs:sequence>
            <xs:attribute type="xs:string" name="field" use="required" />
            <xs:attribute name="type" default="String">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PlainString" />
                        <xs:enumeration value="String" />
                        <xs:enumeration value="BigDecimal" />
                        <xs:enumeration value="Double" />
                        <xs:enumeration value="Float" />
                        <xs:enumeration value="List" />
                        <xs:enumeration value="Long" />
                        <xs:enumeration value="Integer" />
                        <xs:enumeration value="Date" />
                        <xs:enumeration value="Time" />
                        <xs:enumeration value="Timestamp" />
                        <xs:enumeration value="Boolean" />
                        <xs:enumeration value="Object" />
                        <xs:enumeration value="Map" />
                        <xs:enumeration value="Indicator" /><!-- SCIPIO: special type; returns "Y" or "N" string instead of true/false -->
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute name="global" type="xs:boolean" default="false"/>
            <xs:attribute name="to-scope" default="screen">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="screen" />
                        <xs:enumeration value="user" />
                        <xs:enumeration value="application" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
            <xs:attribute type="xs:string" name="pass-value">
                <xs:annotation>
                    <xs:documentation>Value when condition evaluates to true.
                        Default: true for Boolean, "true" for String/PlainString, "Y" for Indicator, null for others</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute type="xs:string" name="fail-value">
                <xs:annotation>
                    <xs:documentation>Value when condition evaluates to true.
                        Default: false for Boolean, "false" for String/PlainString, "N" for Indicator, null for others</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute type="xs:string" name="use-when">
                <xs:annotation>
                    <xs:documentation>A boolean expression which controls whether the command actually takes place. 
                        Supports flexible expressions (EL, groovy:), only.
                        Must resolve to either "true" or "false", as string representation of boolean.</xs:documentation>
                </xs:annotation>
            </xs:attribute>
            <xs:attribute name="only-if-field">
                <xs:annotation>
                    <xs:documentation>Sets only if the target field is empty or null (empty includes null).
                        NOTE: 2016-11-09: this respects the global flag if globalContext is present, 
                            but currently does not respect the to-scope (FIXME?).</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="null" />
                        <xs:enumeration value="empty" />
                    </xs:restriction>
                </xs:simpleType>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:element name="close-object" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Closes a Closeable, AutoCloseable or EntityListIterator object if not null.
                Unknown types will register an error.
                Added 2019-05-17 for 2.1.0.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="throw-exception" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>SCIPIO: Throws an exception, which if not a runtime exception may be wrapped in one.
                Warning: This was first written for use with catch-actions from widget-screen.xsd, and untested elsewhere.
                Added 2019-05-17 for 2.1.0.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:attribute type="xs:string" name="field" use="required" />
        </xs:complexType>
    </xs:element>
    <xs:element name="if" substitutionGroup="AllActions">
        <xs:annotation>
            <xs:documentation>
                Performs conditional processing on blocks of code.
                This operation specifies combinations of conditions, alternate conditions,
                and operations to run based on the evaluation of condition expressions.
                
                SCIPIO: Adapted from simple-methods-v2 to provide basic way to conditionals
                without the heavy widget elements.
                2016-11-11: Added for 1.14.3.
            </xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element name="condition" type="IfCond-Condition" minOccurs="0" maxOccurs="1" />
                <xs:element name="then" type="IfCond-Then"/>
                <xs:element minOccurs="0" maxOccurs="unbounded" name="else-if" type="IfCond-ElseIf"/>
                <xs:element minOccurs="0" name="else" type="IfCond-Else"/>
            </xs:sequence>
            <xs:attribute name="condition">
                <xs:annotation>
                    <xs:documentation>SCIPIO: Condition boolean expression (supporting flexible expressions), alternative to
                        condition element. Must evaluate strictly to the value "true" or "false".</xs:documentation>
                </xs:annotation>
            </xs:attribute>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="IfCond-Condition">
        <xs:annotation>
            <xs:documentation>
                Combines a group of conditional elements into a single logical (true/false) expression.
                
                SCIPIO: Adapted from simple-methods-v2 to provide basic way to conditionals
                without the heavy widget elements.
                In addition, now supports an inline quick condition expression attribute as alternative to the condition element.
                2016-11-15: Added for 1.14.3.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element ref="AllConditionals"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="IfCond-Then">
        <xs:annotation>
            <xs:documentation>
                Contains a block of code to be executed when a condition element evaluates to true.
                
                SCIPIO: Adapted from simple-methods-v2 to provide basic way to conditionals
                without the heavy widget elements.
                2016-11-11: Added for 1.14.3.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="AllActions"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="IfCond-ElseIf">
        <xs:annotation>
            <xs:documentation>
                Contains a condition and a block of code to be evaluated/executed when a parent condition evaluates to false.
                This element must contain two sub-elements: condition and then.
                If the condition of the parent element evaluates to false, then this element's condition will be evaluated,
                and if that condition evaluates to true, then the operations under the then element will be run.
                
                SCIPIO: Adapted from simple-methods-v2 to provide basic way to conditionals
                without the heavy widget elements. 
                In addition, now supports an inline quick condition expression attribute as alternative to the condition element.
                2016-11-15: Added for 1.14.3.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="condition" type="IfCond-Condition" minOccurs="0" maxOccurs="1" />
            <xs:element name="then" type="IfCond-Then"/>
        </xs:sequence>
        <xs:attribute name="condition">
            <xs:annotation>
                <xs:documentation>SCIPIO: Condition boolean expression (supporting flexible expressions), alternative to
                    condition element. Must evaluate strictly to the value "true" or "false".</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="IfCond-Else">
        <xs:annotation>
            <xs:documentation>
                Contains a block of code to be executed when a condition evaluates to false.
                
                SCIPIO: Adapted from simple-methods-v2 to provide basic way to conditionals
                without the heavy widget elements.
                2016-11-11: Added for 1.14.3.
            </xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="AllActions"/>
        </xs:sequence>
    </xs:complexType>
</xs:schema>