vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-operators.xml

<?xml version="1.0"?>
<!--
  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.
-->
<operators>
    <!-- op:add-dayTimeDuration-to-date( $arg1 as xs:date, $arg2 as xs:dayTimeDuration)  as xs:date -->
    <operator name="op:add-dayTimeDuration-to-date">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:date"/>
    </operator>

    <!-- op:add-dayTimeDuration-to-dateTime( $arg1 as xs:dateTime, $arg2 as xs:dayTimeDuration)  as xs:dateTime -->
    <operator name="op:add-dayTimeDuration-to-dateTime">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:dateTime"/>
    </operator>

    <!-- op:add-dayTimeDuration-to-time( $arg1 as xs:time, $arg2 as xs:dayTimeDuration)  as xs:time -->
    <operator name="op:add-dayTimeDuration-to-time">
        <param name="arg1" type="xs:time"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:time"/>
    </operator>

    <!-- op:add-dayTimeDurations( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration)  as xs:dayTimeDuration -->
    <operator name="op:add-dayTimeDurations">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:dayTimeDuration"/>
    </operator>

    <!-- op:add-yearMonthDuration-to-date( $arg1 as xs:date, $arg2 as xs:yearMonthDuration)  as xs:date -->
    <operator name="op:add-yearMonthDuration-to-date">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:date"/>
    </operator>

    <!-- op:add-yearMonthDuration-to-dateTime( $arg1 as xs:dateTime, $arg2 as xs:yearMonthDuration)  as xs:dateTime -->
    <operator name="op:add-yearMonthDuration-to-dateTime">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:dateTime"/>
    </operator>

    <!-- op:add-yearMonthDurations( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration)  as xs:yearMonthDuration -->
    <operator name="op:add-yearMonthDurations">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:yearMonthDuration"/>
    </operator>

    <!-- op:base64Binary-equal( $value1 as xs:base64Binary, $value2 as xs:base64Binary)  as xs:boolean -->
    <operator name="op:base64Binary-equal">
        <param name="value1" type="xs:base64Binary"/>
        <param name="value2" type="xs:base64Binary"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:boolean-equal($value1  as xs:boolean, $value2 as xs:boolean)  as xs:boolean -->
    <operator name="op:boolean-equal">
        <param name="value1" type="xs:boolean"/>
        <param name="value2" type="xs:boolean"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:boolean-greater-than( $arg1 as xs:boolean, $arg2 as xs:boolean)  as xs:boolean -->
    <operator name="op:boolean-greater-than">
        <param name="value1" type="xs:boolean"/>
        <param name="value2" type="xs:boolean"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:boolean-less-than( $arg1 as xs:boolean, $arg2 as xs:boolean)  as xs:boolean -->
    <operator name="op:boolean-less-than">
        <param name="value1" type="xs:boolean"/>
        <param name="value2" type="xs:boolean"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:concatenate($arg as item()*)  as item()* -->
    <operator name="op:concatenate" varargs="true">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.ConcatenateScalarEvaluatorFactory"/>
    </operator>

    <!-- op:date-equal($arg1  as xs:date, $arg2 as xs:date)  as xs:boolean -->
    <operator name="op:date-equal">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:date"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:date-greater-than( $arg1 as xs:date, $arg2 as xs:date)  as xs:boolean -->
    <operator name="op:date-greater-than">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:date"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:date-less-than($arg1  as xs:date, $arg2 as xs:date)  as xs:boolean -->
    <operator name="op:date-less-than">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:date"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:dateTime-equal($arg1  as xs:dateTime, $arg2 as xs:dateTime)  as xs:boolean -->
    <operator name="op:dateTime-equal">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:dateTime"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:dateTime-greater-than( $arg1 as xs:dateTime, $arg2 as xs:dateTime)  as xs:boolean -->
    <operator name="op:dateTime-greater-than">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:dateTime"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:dateTime-less-than( $arg1 as xs:dateTime, $arg2 as xs:dateTime)  as xs:boolean -->
    <operator name="op:dateTime-less-than">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:dateTime"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:dayTimeDuration-greater-than( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration)  as xs:boolean -->
    <operator name="op:dayTimeDuration-greater-than">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:dayTimeDuration-less-than( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration)  as xs:boolean -->
    <operator name="op:dayTimeDuration-less-than">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:divide-dayTimeDuration( $arg1 as xs:dayTimeDuration, $arg2 as xs:double)  as xs:dayTimeDuration -->
    <operator name="op:divide-dayTimeDuration">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:double"/>
        <return type="xs:dayTimeDuration"/>
    </operator>

    <!-- op:divide-dayTimeDuration-by-dayTimeDuration( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration)  as xs:decimal -->
    <operator name="op:divide-dayTimeDuration-by-dayTimeDuration">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:decimal"/>
    </operator>

    <!-- op:divide-yearMonthDuration( $arg1 as xs:yearMonthDuration, $arg2 as xs:double)  as xs:yearMonthDuration -->
    <operator name="op:divide-yearMonthDuration">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:double"/>
        <return type="xs:yearMonthDuration"/>
    </operator>

    <!-- op:divide-yearMonthDuration-by-yearMonthDuration( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration)  as xs:decimal -->
    <operator name="op:divide-yearMonthDuration-by-yearMonthDuration">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:decimal"/>
    </operator>

    <!-- op:duration-equal($arg1  as xs:duration, $arg2 as xs:duration)  as xs:boolean -->
    <operator name="op:duration-equal">
        <param name="arg1" type="xs:duration"/>
        <param name="arg2" type="xs:duration"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:except($parameter1  as node()*, $parameter2 as node()*)  as node()* -->
    <operator name="op:except">
        <param name="parameter1" type="node()*"/>
        <param name="parameter2" type="node()*"/>
        <return type="node()*"/>
        <!-- implementation assumes input in document order -->
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- op:gDay-equal($arg1  as xs:gDay, $arg2 as xs:gDay)  as xs:boolean -->
    <operator name="op:gDay-equal">
        <param name="arg1" type="xs:gDay"/>
        <param name="arg2" type="xs:gDay"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:gMonth-equal($arg1  as xs:gMonth, $arg2 as xs:gMonth)  as xs:boolean -->
    <operator name="op:gMonth-equal">
        <param name="arg1" type="xs:gMonth"/>
        <param name="arg2" type="xs:gMonth"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:gMonthDay-equal($arg1  as xs:gMonthDay, $arg2 as xs:gMonthDay)  as xs:boolean -->
    <operator name="op:gMonthDay-equal">
        <param name="arg1" type="xs:gMonthDay"/>
        <param name="arg2" type="xs:gMonthDay"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:gYear-equal($arg1  as xs:gYear, $arg2 as xs:gYear)  as xs:boolean -->
    <operator name="op:gYear-equal">
        <param name="arg1" type="xs:gYear"/>
        <param name="arg2" type="xs:gYear"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:gYearMonth-equal( $arg1 as xs:gYearMonth, $arg2 as xs:gYearMonth)  as xs:boolean -->
    <operator name="op:gYearMonth-equal">
        <param name="arg1" type="xs:gYearMonth"/>
        <param name="arg2" type="xs:gYearMonth"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:hexBinary-equal($value1 as xs:hexBinary, $value2 as xs:hexBinary) as xs:boolean -->
    <operator name="op:hexBinary-equal">
        <param name="arg1" type="xs:hexBinary"/>
        <param name="arg2" type="xs:hexBinary"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:intersect($parameter1 as node()*, $parameter2 as node()*) as node()* -->
    <operator name="op:intersect">
        <param name="parameter1" type="node()*"/>
        <param name="parameter2" type="node()*"/>
        <return type="node()*"/>
        <!-- implementation assumes input in document order -->
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- op:is-same-node($parameter1 as node(), $parameter2 as node()) as xs:boolean -->
    <operator name="op:is-same-node">
        <param name="parameter1" type="node()"/>
        <param name="parameter2" type="node()"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:multiply-dayTimeDuration( $arg1 as xs:dayTimeDuration, $arg2 as xs:double)  as xs:dayTimeDuration -->
    <operator name="op:multiply-dayTimeDuration">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:double"/>
        <return type="xs:dayTimeDuration"/>
    </operator>

    <!-- op:multiply-yearMonthDuration( $arg1 as xs:yearMonthDuration, $arg2 as xs:double)  as xs:yearMonthDuration -->
    <operator name="op:multiply-yearMonthDuration">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:double"/>
        <return type="xs:yearMonthDuration"/>
    </operator>

    <!-- op:node-after($parameter1  as node(), $parameter2 as node())  as xs:boolean -->
    <operator name="op:node-after">
        <param name="parameter1" type="node()"/>
        <param name="parameter2" type="node()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.OpNodeAfterEvaluatorFactory"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:node-before($parameter1  as node(), $parameter2 as node())  as xs:boolean -->
    <operator name="op:node-before">
        <param name="parameter1" type="node()"/>
        <param name="parameter2" type="node()"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.OpNodeBeforeEvaluatorFactory"/>
    </operator>

    <!-- op:NOTATION-equal($arg1  as xs:NOTATION, $arg2 as xs:NOTATION)  as xs:boolean -->
    <operator name="op:NOTATION-equal">
        <param name="arg1" type="xs:NOTATION"/>
        <param name="arg2" type="xs:NOTATION"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:numeric-add($arg1  as numeric, $arg2 as numeric)  as numeric -->
    <operator name="op:numeric-add">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
    </operator>

    <!-- op:numeric-divide($arg1  as numeric, $arg2 as numeric)  as numeric -->
    <operator name="op:numeric-divide">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
    </operator>

    <!-- op:numeric-equal($arg1  as numeric, $arg2 as numeric)  as xs:boolean -->
    <operator name="op:numeric-equal">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:numeric-greater-than( $arg1 as numeric, $arg2 as numeric)  as xs:boolean -->
    <operator name="op:numeric-greater-than">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:numeric-integer-divide( $arg1 as numeric, $arg2 as numeric)  as xs:integer -->
    <operator name="op:numeric-integer-divide">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xs:integer"/>
    </operator>

    <!-- op:numeric-less-than( $arg1 as numeric, $arg2 as numeric)  as xs:boolean -->
    <operator name="op:numeric-less-than">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:numeric-mod($arg1  as numeric, $arg2 as numeric)  as numeric -->
    <operator name="op:numeric-mod">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
    </operator>

    <!-- op:numeric-multiply( $arg1 as numeric, $arg2 as numeric)  as numeric -->
    <operator name="op:numeric-multiply">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
    </operator>

    <!-- op:numeric-subtract( $arg1 as numeric, $arg2 as numeric)  as numeric -->
    <operator name="op:numeric-subtract">
        <param name="arg1" type="xsext:numeric"/>
        <param name="arg2" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
    </operator>

    <!-- op:numeric-unary-minus( $arg as numeric) as  numeric -->
    <operator name="op:numeric-unary-minus">
        <param name="arg1" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.unary.NumericUnaryMinusScalarEvaluatorFactory"/>
    </operator>

    <!-- op:numeric-unary-plus( $arg as numeric) as  numeric -->
    <operator name="op:numeric-unary-plus">
        <param name="arg1" type="xsext:numeric"/>
        <return type="xsext:numeric"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.unary.NumericUnaryPlusScalarEvaluatorFactory"/>
    </operator>

    <!-- op:QName-equal($arg1  as xs:QName, $arg2 as xs:QName)  as xs:boolean -->
    <operator name="op:QName-equal">
        <param name="arg1" type="xs:QName"/>
        <param name="arg2" type="xs:QName"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:subtract-dates($arg1  as xs:date, $arg2 as xs:date)  as xs:dayTimeDuration? -->
    <operator name="op:subtract-dates">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:date"/>
        <return type="xs:dayTimeDuration?"/>
    </operator>

    <!-- op:subtract-dateTimes( $arg1 as xs:dateTime, $arg2 as xs:dateTime)  as xs:dayTimeDuration? -->
    <operator name="op:subtract-dateTimes">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:dateTime"/>
        <return type="xs:dayTimeDuration?"/>
    </operator>

    <!-- op:subtract-dayTimeDuration-from-date( $arg1 as xs:date, $arg2 as xs:dayTimeDuration)  as xs:date -->
    <operator name="op:subtract-dayTimeDuration-from-date">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:date"/>
    </operator>

    <!-- op:subtract-dayTimeDuration-from-dateTime( $arg1 as xs:dateTime, $arg2 as xs:dayTimeDuration)  as xs:dateTime -->
    <operator name="op:subtract-dayTimeDuration-from-dateTime">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:dateTime"/>
    </operator>

    <!-- op:subtract-dayTimeDuration-from-time( $arg1 as xs:time, $arg2 as xs:dayTimeDuration)  as xs:time -->
    <operator name="op:subtract-dayTimeDuration-from-time">
        <param name="arg1" type="xs:time"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:time"/>
    </operator>

    <!-- op:subtract-dayTimeDurations( $arg1 as xs:dayTimeDuration, $arg2 as xs:dayTimeDuration)  as xs:dayTimeDuration -->
    <operator name="op:subtract-dayTimeDurations">
        <param name="arg1" type="xs:dayTimeDuration"/>
        <param name="arg2" type="xs:dayTimeDuration"/>
        <return type="xs:dayTimeDuration"/>
    </operator>

    <!-- op:subtract-times($arg1  as xs:time, $arg2 as xs:time)  as xs:dayTimeDuration -->
    <operator name="op:subtract-times">
        <param name="arg1" type="xs:time"/>
        <param name="arg2" type="xs:time"/>
        <return type="xs:dayTimeDuration"/>
    </operator>

    <!-- op:subtract-yearMonthDuration-from-date( $arg1 as xs:date, $arg2 as xs:yearMonthDuration)  as xs:date -->
    <operator name="op:subtract-yearMonthDuration-from-date">
        <param name="arg1" type="xs:date"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:date"/>
    </operator>

    <!-- op:subtract-yearMonthDuration-from-dateTime( $arg1 as xs:dateTime, $arg2 as xs:yearMonthDuration)  as xs:dateTime -->
    <operator name="op:subtract-yearMonthDuration-from-dateTime">
        <param name="arg1" type="xs:dateTime"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:dateTime"/>
    </operator>

    <!-- op:subtract-yearMonthDurations( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration)  as xs:yearMonthDuration -->
    <operator name="op:subtract-yearMonthDurations">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:yearMonthDuration"/>
    </operator>

    <!-- op:time-equal($arg1  as xs:time, $arg2 as xs:time)  as xs:boolean -->
    <operator name="op:time-equal">
        <param name="arg1" type="xs:time"/>
        <param name="arg2" type="xs:time"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:time-greater-than( $arg1 as xs:time, $arg2 as xs:time)  as xs:boolean -->
    <operator name="op:time-greater-than">
        <param name="arg1" type="xs:time"/>
        <param name="arg2" type="xs:time"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:time-less-than($arg1  as xs:time, $arg2 as xs:time)  as xs:boolean -->
    <operator name="op:time-less-than">
        <param name="arg1" type="xs:time"/>
        <param name="arg2" type="xs:time"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:to($firstval as  xs:integer, $lastval as xs:integer)  as xs:integer* -->
    <operator name="op:to">
        <param name="firstval" type="xs:integer"/>
        <param name="lastval" type="xs:integer"/>
        <return type="xs:integer*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.OpToScalarEvaluatorFactory"/>
    </operator>

    <!-- op:union($parameter1  as node()*, $parameter2 as node()*)  as node()* -->
    <operator name="op:union">
        <param name="parameter1" type="node()*"/>
        <param name="parameter2" type="node()*"/>
        <return type="node()*"/>
        <!-- as we do the doc-order-sort and the duplicate elimination -->
        <!-- after the concatenation, we can reuse the concat iterator -->
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- op:yearMonthDuration-greater-than( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration)  as xs:boolean -->
    <operator name="op:yearMonthDuration-greater-than">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- op:yearMonthDuration-less-than( $arg1 as xs:yearMonthDuration, $arg2 as xs:yearMonthDuration)  as xs:boolean -->
    <operator name="op:yearMonthDuration-less-than">
        <param name="arg1" type="xs:yearMonthDuration"/>
        <param name="arg2" type="xs:yearMonthDuration"/>
        <return type="xs:boolean"/>
    </operator>

    <!-- fn:avg-local($arg as xs:anyAtomicType*) as xs:anyAtomicType? -->
    <operator name="opext:avg-local">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.AvgLocalAggregateEvaluatorFactory"/>
    </operator>

    <!-- fn:avg-global($arg as xs:anyAtomicType*) as xs:anyAtomicType? -->
    <operator name="opext:avg-global">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.AvgGlobalAggregateEvaluatorFactory"/>
    </operator>

    <!-- opext:ordered($arg as item()*) as item()* -->
    <operator name="opext:ordered">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
    </operator>

    <!-- opext:unordered($arg as item()*) as item()* -->
    <operator name="opext:unordered">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
    </operator>

    <!-- opext:value-eq($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
    <operator name="opext:value-eq">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueEqComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:value-ne($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
    <operator name="opext:value-ne">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueNeComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:value-lt($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
    <operator name="opext:value-lt">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueLtComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:value-le($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
    <operator name="opext:value-le">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueLeComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:value-gt($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
    <operator name="opext:value-gt">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueGtComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:value-ge($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
    <operator name="opext:value-ge">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueGeComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:general-eq($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
    <operator name="opext:general-eq">
        <param name="arg1" type="item()*"/>
        <param name="arg2" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.general.GeneralEqComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:general-ne($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
    <operator name="opext:general-ne">
        <param name="arg1" type="item()*"/>
        <param name="arg2" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.general.GeneralNeComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:general-lt($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
    <operator name="opext:general-lt">
        <param name="arg1" type="item()*"/>
        <param name="arg2" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.general.GeneralLtComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:general-le($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
    <operator name="opext:general-le">
        <param name="arg1" type="item()*"/>
        <param name="arg2" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.general.GeneralLeComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:general-gt($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
    <operator name="opext:general-gt">
        <param name="arg1" type="item()*"/>
        <param name="arg2" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.general.GeneralGtComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:general-ge($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
    <operator name="opext:general-ge">
        <param name="arg1" type="item()*"/>
        <param name="arg2" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.general.GeneralGeComparisonScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:add($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:anyAtomicType? -->
    <operator name="opext:add">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.arithmetic.AddScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:subtract($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:anyAtomicType? -->
    <operator name="opext:subtract">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.arithmetic.SubtractScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:multiply($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:anyAtomicType? -->
    <operator name="opext:multiply">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.arithmetic.MultiplyScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:divide($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:anyAtomicType? -->
    <operator name="opext:divide">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.arithmetic.DivideScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:idiv($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:anyAtomicType? -->
    <operator name="opext:idiv">
        <param name="arg1" type="xsext:numeric?"/>
        <param name="arg2" type="xsext:numeric?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.arithmetic.IntegerDivideScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:mod($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:anyAtomicType? -->
    <operator name="opext:mod">
        <param name="arg1" type="xsext:numeric?"/>
        <param name="arg2" type="xsext:numeric?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.arithmetic.ModScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:and($arg1 as xs:boolean?, $arg2 as xs:boolean?) as xs:boolean? -->
    <operator name="opext:and">
        <param name="arg1" type="xs:boolean?"/>
        <param name="arg2" type="xs:boolean?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.bool.AndScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:or($arg1 as xs:boolean?, $arg2 as xs:boolean?) as xs:boolean? -->
    <operator name="opext:or">
        <param name="arg1" type="xs:boolean?"/>
        <param name="arg2" type="xs:boolean?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.bool.OrScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:sort-nodes-asc($arg as node()*) as node()* -->
    <operator name="opext:sort-nodes-asc">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.nodeid.SortDistinctNodesAscOrAtomicsScalarEvaluatorFactory"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:sort-nodes-asc-or-atomics($arg as item()*) as item()* -->
    <operator name="opext:sort-nodes-asc-or-atomics">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.nodeid.SortDistinctNodesAscOrAtomicsScalarEvaluatorFactory"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:sort-distinct-nodes-asc($arg as node()*) as node()* -->
    <operator name="opext:sort-distinct-nodes-asc">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:sort-distinct-nodes-asc-or-atomics($arg as item()*) as item()* -->
    <operator name="opext:sort-distinct-nodes-asc-or-atomics">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.nodeid.SortDistinctNodesAscOrAtomicsScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:distinct-nodes-or-atomics($arg as item()*) as item()* -->
    <operator name="opext:distinct-nodes-or-atomics">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.nodeid.SortDistinctNodesAscOrAtomicsScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:sort-nodes-desc($arg as node()*) as node()* -->
    <operator name="opext:sort-nodes-desc">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:sort-nodes-desc-or-atomics($arg as item()*) as item()* -->
    <operator name="opext:sort-nodes-desc-or-atomics">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:sort-distinct-nodes-desc($arg as node()*) as node()* -->
    <operator name="opext:sort-distinct-nodes-desc">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:sort-distinct-nodes-desc-or-atomics($arg as item()*) as item()* -->
    <operator name="opext:sort-distinct-nodes-desc-or-atomics">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
    </operator>

    <!-- opext:id-from-node($arg as item()) as xs:integer -->
    <operator name="opext:id-from-node">
        <param name="arg" type="item()"/>
        <return type="xs:integer"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.IdFromNodeScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:local-id-from-node($arg as item()) as xs:int -->
    <operator name="opext:local-id-from-node">
        <param name="arg" type="item()"/>
        <return type="xs:int"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.LocalIdFromNodeScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:tree-id-from-node($arg as item()) as xs:int -->
    <operator name="opext:tree-id-from-node">
        <param name="arg" type="item()"/>
        <return type="xs:int"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.TreeIdFromNodeScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:deflate-sequences($arg as item()*) as item()* -->
    <operator name="opext:deflate-sequences">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:pi-constructor($target as xs:sring, $content as xs:string) as node() -->
    <operator name="opext:pi-constructor">
        <param name="target" type="xs:string"/>
        <param name="content" type="xs:string"/>
        <return type="node()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.PINodeConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:comment-constructor($content as xs:string) as node() -->
    <operator name="opext:comment-constructor">
        <param name="content" type="xs:string"/>
        <return type="node()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.CommentNodeConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:element-constructor($name as xs:QName, $content as item()*) as node() -->
    <operator name="opext:element-constructor">
        <param name="name" type="xs:QName"/>
        <param name="content" type="item()*"/>
        <return type="node()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.ElementNodeConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:attribute-constructor($name as xs:QName, $content as xs:anyAtomicType*) as node() -->
    <operator name="opext:attribute-constructor">
        <param name="name" type="xs:QName"/>
        <param name="content" type="xs:anyAtomicType*"/>
        <return type="node()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.AttributeNodeConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:text-constructor($content as xs:anyAtomicType*) as node() -->
    <operator name="opext:text-constructor">
        <param name="content" type="xs:anyAtomicType*"/>
        <return type="node()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.TextNodeConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:document-constructor($content as node()) as node() -->
    <operator name="opext:document-constructor">
        <param name="content" type="node()"/>
        <return type="node()"/>
    </operator>

    <!-- opext:array-constructor($expression as item()*) as array() -->
    <operator name="opext:array-constructor">
        <param name="expression" type="item()*"/>
        <return type="array()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.jsonitem.ArrayConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:object-constructor($expression as item()*) as object() -->
    <operator name="opext:object-constructor">
        <param name="expression" type="item()*"/>
        <return type="object()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.jsonitem.ObjectConstructorScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:if-then-else($condition as xs:boolean, $then as item()*, $else as item()*) as item()* -->
    <operator name="opext:if-then-else">
        <param name="condition" type="xs:boolean"/>
        <param name="then" type="item()*"/>
        <param name="else" type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.conditional.IfThenElseScalarEvaluatorFactory"/>
        <return type="item()*"/>
    </operator>

    <!-- opext:ancestor($arg as node()*) as node()* -->
    <operator name="opext:ancestor">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:ancestor-or-self($arg as node()*) as node()* -->
    <operator name="opext:ancestor-or-self">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:attribute($arg as node()*) as node()* -->
    <operator name="opext:attribute">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.step.AttributePathStepScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:child($arg as node()*) as node()* -->
    <operator name="opext:child">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.step.ChildPathStepScalarEvaluatorFactory"/>
        <runtime type="unnesting" class="org.apache.vxquery.runtime.functions.step.ChildPathStepUnnestingEvaluatorFactory"/>
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:descendant($arg as node()*) as node()* -->
    <operator name="opext:descendant">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.step.DescendantPathStepScalarEvaluatorFactory"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.uniquenodes.UniqueNodesNOPropagationPolicy"/>
    </operator>

    <!-- opext:descendant-or-self($arg as node()*) as node()* -->
    <operator name="opext:descendant-or-self">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.step.DescendantOrSelfPathStepScalarEvaluatorFactory"/>
        <runtime type="unnesting" class="org.apache.vxquery.runtime.functions.step.DescendantOrSelfPathStepUnnestingEvaluatorFactory"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.uniquenodes.UniqueNodesNOPropagationPolicy"/>
    </operator>

    <!-- opext:following($arg as node()*) as node()* -->
    <operator name="opext:following">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:following-sibling($arg as node()*) as node()* -->
    <operator name="opext:following-sibling">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:parent($arg as node()*) as node()* -->
    <operator name="opext:parent">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:preceding($arg as node()*) as node()* -->
    <operator name="opext:preceding">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:preceding-sibling($arg as node()*) as node()* -->
    <operator name="opext:preceding-sibling">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
    </operator>

    <!-- opext:self($arg as node()*) as node()* -->
    <operator name="opext:self">
        <param name="arg" type="node()*"/>
        <return type="node()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.step.SelfPathStepScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:sequence($arg as item()*) as item()* -->
    <operator name="opext:sequence">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.sequence.SequenceAggregateEvaluatorFactory"/>
    </operator>

    <!-- opext:iterate($arg as item()*) as item() -->
    <operator name="opext:iterate">
        <param name="arg" type="item()*"/>
        <return type="item()"/>
        <runtime type="unnesting" class="org.apache.vxquery.runtime.functions.sequence.IterateUnnestingEvaluatorFactory"/>
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </operator>

    <!-- opext:validate-lax($arg as item()*) as item()* -->
    <operator name="opext:validate-lax">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
    </operator>

    <!-- opext:validate-strict($arg as item()*) as item()* -->
    <operator name="opext:validate-strict">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
    </operator>

    <!-- opext:promote($arg as item()*, $type as xsext:type) as item()* -->
    <operator name="opext:promote">
        <param name="arg" type="item()*"/>
        <param name="type" type="xs:int"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.type.PromoteScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:treat($arg as item()*, $type as xsext:type) as item()* -->
    <operator name="opext:treat">
        <param name="arg" type="item()*"/>
        <param name="type" type="xs:int"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.type.TreatScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:cast($arg as item()*, $type as xsext:type) as item()* -->
    <operator name="opext:cast">
        <param name="arg" type="item()*"/>
        <param name="type" type="xs:int"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.cast.CastScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:castable($arg as item()*, $type as xsext:type) as xs:boolean -->
    <operator name="opext:castable">
        <param name="arg" type="item()*"/>
        <param name="type" type="xs:int"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.castable.CastableScalarEvaluatorFactory"/>
    </operator>

    <!-- opext:instance-of($arg as item()*, $type as xsext:type) as xs:boolean -->
    <operator name="opext:instance-of">
        <param name="arg" type="item()*"/>
        <param name="type" type="xs:int"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.type.InstanceOfScalarEvaluatorFactory"/>
    </operator>
</operators>