vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-functions.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.
-->
<functions>
    <!-- fn:abs($arg as  numeric?) as numeric? -->
    <function name="fn:abs">
        <param name="arg" type="xsext:numeric?"/>
        <return type="xsext:numeric?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.numeric.FnAbsScalarEvaluatorFactory"/>
    </function>

    <!-- fn:adjust-date-to-timezone( $arg as xs:date?) as  xs:date? -->
    <function name="fn:adjust-date-to-timezone">
        <param name="arg" type="xs:date?"/>
        <return type="xs:date?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnAdjustDateToTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:adjust-date-to-timezone( $arg as xs:date?, $timezone as xs:dayTimeDuration?)  as xs:date? -->
    <function name="fn:adjust-date-to-timezone">
        <param name="arg" type="xs:date?"/>
        <param name="timezone" type="xs:dayTimeDuration?"/>
        <return type="xs:date?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnAdjustDateToTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:adjust-dateTime-to-timezone( $arg as xs:dateTime?)  as xs:dateTime? -->
    <function name="fn:adjust-dateTime-to-timezone">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:dateTime?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnAdjustDateTimeToTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:adjust-dateTime-to-timezone( $arg as xs:dateTime?, $timezone as xs:dayTimeDuration?)  as xs:dateTime? -->
    <function name="fn:adjust-dateTime-to-timezone">
        <param name="arg" type="xs:dateTime?"/>
        <param name="timezone" type="xs:dayTimeDuration?"/>
        <return type="xs:dateTime?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnAdjustDateTimeToTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:adjust-time-to-timezone( $arg as xs:time?) as  xs:time? -->
    <function name="fn:adjust-time-to-timezone">
        <param name="arg" type="xs:time?"/>
        <return type="xs:time?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnAdjustTimeToTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:adjust-time-to-timezone( $arg as xs:time?, $timezone as xs:dayTimeDuration?)  as xs:time? -->
    <function name="fn:adjust-time-to-timezone">
        <param name="arg" type="xs:time?"/>
        <param name="timezone" type="xs:dayTimeDuration?"/>
        <return type="xs:time?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnAdjustTimeToTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:avg($arg as  xs:anyAtomicType*) as xs:anyAtomicType? -->
    <function name="fn:avg">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnAvgScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnAvgAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:base-uri() as  xs:anyURI? -->
    <function name="fn:base-uri" implicit-context="true">
        <return type="xs:anyURI?"/>
    </function>

    <!-- fn:base-uri($arg  as node()?) as  xs:anyURI? -->
    <function name="fn:base-uri">
        <param name="arg" type="node()?"/>
        <return type="xs:anyURI?"/>
    </function>

    <!-- fn:boolean($arg as  item()*) as xs:boolean -->
    <function name="fn:boolean">
        <param name="arg" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.bool.FnBooleanScalarEvaluatorFactory"/>
    </function>

    <!-- fn:ceiling($arg as  numeric?) as numeric? -->
    <function name="fn:ceiling">
        <param name="arg" type="xsext:numeric?"/>
        <return type="xsext:numeric?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.numeric.FnCeilingScalarEvaluatorFactory"/>
    </function>

    <!-- fn:codepoint-equal($comparand1  as xs:string?, $comparand2 as xs:string?)  as xs:boolean? -->
    <function name="fn:codepoint-equal">
        <param name="comparand1" type="xs:string?"/>
        <param name="comparand2" type="xs:string?"/>
        <return type="xs:boolean?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnCodepointEqualEvaluatorFactory"/>
    </function>

    <!-- fn:codepoints-to-string( $arg as xs:integer*)  as xs:string -->
    <function name="fn:codepoints-to-string">
        <param name="arg" type="xs:integer*"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnCodepointsToStringEvaluatorFactory"/>
    </function>

    <!-- fn:collection() as  node()* -->
    <function name="fn:collection">
        <return type="node()*"/>
    </function>

    <!-- fn:collection($arg  as xs:string?) as  node()* -->
    <function name="fn:collection">
        <param name="arg" type="xs:string?"/>
        <return type="node()*"/>
        <!-- Collection operator is added during the rewrite rules phase.  -->
    </function>

    <!-- fn:build-index-on-collection($arg  as xs:string?, $indexFolder  as xs:string?) as  node()* -->
    <function name="fn:build-index-on-collection">
        <param name="collection-folder" type="xs:string?"/>
        <param name="index-folder" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.index.IndexConstructorScalarEvaluatorFactory"/>
    </function>

    <!-- fn:update-index($indexFolder  as xs:string?) as  node()* -->
    <function name="fn:update-index">
        <param name="index-folder" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar"
                 class="org.apache.vxquery.runtime.functions.index.IndexUpdaterEvaluatorFactory"/>
    </function>

    <!-- fn:delete-index($indexFolder  as xs:string?) as  node()* -->
    <function name="fn:delete-index">
        <param name="index-folder" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar"
                 class="org.apache.vxquery.runtime.functions.index.IndexDeleteEvaluatorFactory"/>
    </function>

    <!-- fn:collection-from-index($indexfolder  as xs:string?, $elementpath as xs:string?) as  node()* -->
    <function name="fn:collection-from-index">
        <param name="index-folder" type="xs:string?"/>
        <param name="element-path" type="xs:string?"/>
        <return type="node()*"/>
        <runtime type="unnesting" class="org.apache.vxquery.runtime.functions.index.CollectionFromIndexUnnestingEvaluatorFactory"/>
        <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>
    </function>

    <!-- fn:collection-with-tag($arg1  as xs:string?, $arg2 as xs:string?) as  node()* -->
    <function name="fn:collection-with-tag">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <return type="node()*"/>
        <!-- CollectionWithTag operator is added during the rewrite rules phase.  -->
    </function>

    <!-- fn:compare($comparand1  as xs:string?, $comparand2 as xs:string?)  as xs:integer?  -->
    <function name="fn:compare">
        <param name="comparand1" type="xs:string?"/>
        <param name="comparand2" type="xs:string?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnCompareEvaluatorFactory"/>
    </function>

    <!-- fn:compare($comparand1  as xs:string?, $comparand2 as xs:string?, $collation as xs:string)  as xs:integer?  -->
    <function name="fn:compare">
        <param name="comparand1" type="xs:string?"/>
        <param name="comparand2" type="xs:string?"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnCompareEvaluatorFactory"/>
    </function>

    <!-- fn:concat($arg1 as  xs:anyAtomicType?, $arg2 as xs:anyAtomicType?, ...) as xs:string -->
    <function name="fn:concat" varargs="true">
        <param name="arg1" type="xs:anyAtomicType?"/>
        <param name="arg2" type="xs:anyAtomicType?"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnConcatEvaluatorFactory"/>
    </function>

    <!-- fn:contains($arg1  as xs:string?, $arg2 as xs:string?)  as xs:boolean -->
    <function name="fn:contains">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnContainsEvaluatorFactory"/>
    </function>

    <!-- fn:contains($arg1  as xs:string?, $arg2 as xs:string?, $collation as xs:string)  as xs:boolean -->
    <function name="fn:contains">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:count($arg as  item()*) as xs:integer -->
    <function name="fn:count">
        <param name="arg" type="item()*"/>
        <return type="xs:integer"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnCountScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnCountAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:current-date() as  xs:date -->
    <function name="fn:current-date">
        <return type="xs:date"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnCurrentDateScalarEvaluatorFactory"/>
    </function>

    <!-- fn:current-dateTime()  as xs:dateTime -->
    <function name="fn:current-dateTime">
        <return type="xs:dateTime"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnCurrentDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:current-time() as  xs:time -->
    <function name="fn:current-time">
        <return type="xs:time"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnCurrentTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:data($arg as  item()*) as xs:anyAtomicType* -->
    <function name="fn:data">
        <param name="arg" type="item()*"/>
        <return type="xs:anyAtomicType*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.misc.FnDataScalarEvaluatorFactory"/>
        <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>
    </function>

    <!-- jn:size($expr as  item()*) as xs:anyAtomicType* -->
    <function name="jn:size">
        <param name="expr" type="item()*"/>
        <return type="xs:integer"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.misc.JnSizeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:dateTime($arg1  as xs:date?, $arg2 as xs:time?)  as xs:dateTime?  -->
    <function name="fn:dateTime">
        <param name="arg1" type="xs:date?"/>
        <param name="arg2" type="xs:time?"/>
        <return type="xs:dateTime?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:day-from-date($arg  as xs:date?) as  xs:integer?  -->
    <function name="fn:day-from-date">
        <param name="arg" type="xs:date?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnDayFromDateScalarEvaluatorFactory"/>
    </function>

    <!-- fn:day-from-dateTime( $arg as xs:dateTime?)  as xs:integer?  -->
    <function name="fn:day-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnDayFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:days-from-duration( $arg as xs:duration?)  as xs:integer?  -->
    <function name="fn:days-from-duration">
        <param name="arg" type="xs:duration?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnDaysFromDurationScalarEvaluatorFactory"/>
    </function>

    <!-- fn:deep-equal($parameter1  as item()*, $parameter2 as item()*)  as xs:boolean -->
    <function name="fn:deep-equal">
        <param name="parameter1" type="item()*"/>
        <param name="parameter2" type="item()*"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:deep-equal($parameter1  as item()*, $parameter2 as item()*, $collation as xs:string) as xs:boolean -->
    <function name="fn:deep-equal">
        <param name="parameter1" type="item()*"/>
        <param name="parameter2" type="item()*"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:default-collation()  as xs:string -->
    <function name="fn:default-collation">
        <return type="xs:string"/>
    </function>

    <!-- fn:distinct-values($arg  as xs:anyAtomicType*) as  xs:anyAtomicType* -->
    <function name="fn:distinct-values">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnDistinctValuesScalarEvaluatorFactory"/>
    </function>

    <!-- fn:distinct-values($arg  as xs:anyAtomicType*, $collation as xs:string)  as xs:anyAtomicType* -->
    <function name="fn:distinct-values">
        <param name="arg" type="xs:anyAtomicType*"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:anyAtomicType*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnDistinctValuesScalarEvaluatorFactory"/>
    </function>

    <!-- fn:doc($uri as  xs:string?) as document-node()?  -->
    <function name="fn:doc">
        <param name="uri" type="xs:string?"/>
        <return type="document-node()?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.FnDocScalarEvaluatorFactory"/>
    </function>

    <!-- jn:json-doc($uri as  xs:string?) as json-item()?  -->
    <function name="jn:json-doc">
        <param name="uri" type="xs:string?"/>
        <return type="json-item()?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.JnDocScalarEvaluatorFactory"/>
    </function>

    <!-- jn:parse-json($arg as  xs:string?) as json-item()*  -->
    <function name="jn:parse-json">
        <param name="arg" type="xs:string?"/>
        <return type="json-item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.JnParseJsonScalarEvaluatorFactory"/>
    </function>

    <!-- jn:parse-json($arg as  xs:string?, $options as object()) as json-item()*  -->
    <function name="jn:parse-json">
        <param name="arg" type="xs:string?"/>
        <param name="options" type="item()"/>
        <return type="json-item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.JnParseJsonScalarEvaluatorFactory"/>
    </function>

    <!-- fn:doc-available($uri  as xs:string?) as  xs:boolean -->
    <function name="fn:doc-available">
        <param name="uri" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.FnDocAvailableScalarEvaluatorFactory"/>
    </function>

    <!-- fn:document-uri($arg  as node()?) as  xs:anyURI?  -->
    <function name="fn:document-uri">
        <param name="arg" type="node()?"/>
        <return type="xs:anyURI?"/>
    </function>

    <!-- fn:empty($arg as  item()*) as xs:boolean -->
    <function name="fn:empty">
        <param name="arg" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnEmptyScalarEvaluatorFactory"/>
    </function>

    <!-- fn:encode-for-uri($uri-part  as xs:string?) as  xs:string -->
    <function name="fn:encode-for-uri">
        <param name="uri-part" type="xs:string?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:ends-with($arg1  as xs:string?, $arg2 as xs:string?)  as xs:boolean -->
    <function name="fn:ends-with">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnEndsWithEvaluatorFactory"/>
    </function>

    <!-- fn:ends-with($arg1  as xs:string?, $arg2 as xs:string?, $collation as xs:string)  as xs:boolean -->
    <function name="fn:ends-with">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnEndsWithEvaluatorFactory"/>
    </function>

    <!-- fn:error() as  none -->
    <function name="fn:error">
        <return type="none"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.error.FnErrorScalarEvaluatorFactory"/>
    </function>

    <!-- fn:error($error as  xs:QName) as none -->
    <function name="fn:error">
        <param name="error" type="xs:QName"/>
        <return type="none"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.error.FnErrorScalarEvaluatorFactory"/>
    </function>

    <!-- fn:error($error as  xs:QName?, $description as xs:string)  as none -->
    <function name="fn:error">
        <param name="error" type="xs:QName?"/>
        <param name="description" type="xs:string"/>
        <return type="none"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.error.FnErrorScalarEvaluatorFactory"/>
    </function>

    <!-- fn:error($error as  xs:QName?, $description as xs:string, $error-object as item()*)  as none -->
    <function name="fn:error">
        <param name="error" type="xs:QName?"/>
        <param name="description" type="xs:string"/>
        <param name="error-object" type="item()*"/>
        <return type="none"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.error.FnErrorScalarEvaluatorFactory"/>
    </function>

    <!-- fn:escape-html-uri($uri  as xs:string?) as  xs:string -->
    <function name="fn:escape-html-uri">
        <param name="uri" type="xs:string?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:exactly-one($arg  as item()*) as  item() -->
    <function name="fn:exactly-one">
        <param name="arg" type="item()*"/>
        <return type="item()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnExactlyOneScalarEvaluatorFactory"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </function>

    <!-- fn:exists($arg as  item()*) as xs:boolean -->
    <function name="fn:exists">
        <param name="arg" type="item()*"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnExistsScalarEvaluatorFactory"/>
    </function>

    <!-- fn:false() as  xs:boolean -->
    <function name="fn:false">
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.bool.FnFalseScalarEvaluatorFactory"/>
    </function>

    <!-- fn:floor($arg as  numeric?) as numeric?  -->
    <function name="fn:floor">
        <param name="arg" type="xsext:numeric?"/>
        <return type="xsext:numeric?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.numeric.FnFloorScalarEvaluatorFactory"/>
    </function>

    <!-- fn:hours-from-dateTime( $arg as xs:dateTime?)  as xs:integer?  -->
    <function name="fn:hours-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnHoursFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:hours-from-duration( $arg as xs:duration?)  as xs:integer?  -->
    <function name="fn:hours-from-duration">
        <param name="arg" type="xs:duration?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnHoursFromDurationScalarEvaluatorFactory"/>
    </function>

    <!-- fn:hours-from-time($arg  as xs:time?) as  xs:integer?  -->
    <function name="fn:hours-from-time">
        <param name="arg" type="xs:time?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnHoursFromTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:id($arg as  xs:string*) as element()* -->
    <function name="fn:id">
        <param name="arg" type="xs:string*"/>
        <return type="element()*"/>
    </function>

    <!-- fn:id($arg as  xs:string*, $node as node())  as element()* -->
    <function name="fn:id">
        <param name="arg" type="xs:string*"/>
        <param name="node" type="node()"/>
        <return type="element()*"/>
    </function>

    <!-- fn:idref($arg as  xs:string*) as node()* -->
    <function name="fn:idref">
        <param name="arg" type="xs:string*"/>
        <return type="node()*"/>
    </function>

    <!-- fn:idref($arg as  xs:string*, $node as node())  as node()* -->
    <function name="fn:idref">
        <param name="arg" type="xs:string*"/>
        <param name="node" type="node()"/>
        <return type="node()*"/>
    </function>

    <!-- fn:implicit-timezone()  as xs:dayTimeDuration -->
    <function name="fn:implicit-timezone">
        <return type="xs:dayTimeDuration"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnImplicitTimezoneScalarEvaluatorFactory"/>
    </function>

    <!-- fn:in-scope-prefixes( $element as element())  as xs:string* -->
    <function name="fn:in-scope-prefixes">
        <param name="element" type="element()"/>
        <return type="xs:string*"/>
    </function>

    <!-- fn:index-of($seqParam  as xs:anyAtomicType*, $srchParam as xs:anyAtomicType)  as xs:integer* -->
    <function name="fn:index-of">
        <param name="seqParam" type="xs:anyAtomicType*"/>
        <param name="srcParam" type="xs:anyAtomicType"/>
        <return type="xs:integer*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnIndexOfScalarEvaluatorFactory"/>
    </function>

    <!-- fn:index-of($seqParam  as xs:anyAtomicType*, $srchParam as xs:anyAtomicType, $collation as xs:string)  as xs:integer* -->
    <function name="fn:index-of">
        <param name="seqParam" type="xs:anyAtomicType*"/>
        <param name="srcParam" type="xs:anyAtomicType"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:integer*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnIndexOfScalarEvaluatorFactory"/>
    </function>

    <!-- fn:insert-before($target  as item()*, $position as xs:integer, $inserts as item()*)  as item()* -->
    <function name="fn:insert-before">
        <param name="target" type="item()*"/>
        <param name="position" type="xs:integer"/>
        <param name="inserts" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnInsertBeforeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:iri-to-uri($iri  as xs:string?) as  xs:string -->
    <function name="fn:iri-to-uri">
        <param name="iri" type="xs:string?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:lang($testlang as  xs:string?) as xs:boolean -->
    <function name="fn:lang">
        <param name="testlang" type="xs:string?"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:lang($testlang as  xs:string?, $node as node())  as xs:boolean -->
    <function name="fn:lang">
        <param name="testlang" type="xs:string?"/>
        <param name="node" type="node()"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:last() as  xs:integer -->
    <function name="fn:last">
        <return type="xs:integer"/>
    </function>

    <!-- fn:local-name() as  xs:string -->
    <function name="fn:local-name" implicit-context="true">
        <return type="xs:string"/>
    </function>

    <!-- fn:local-name($arg  as node()?) as  xs:string -->
    <function name="fn:local-name">
        <param name="arg" type="node()?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:local-name-from-QName( $arg as xs:QName?) as  xs:NCName?  -->
    <function name="fn:local-name-from-QName">
        <param name="arg" type="xs:QName?"/>
        <return type="xs:NCName?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.qname.FnLocalNameFromQNameScalarEvaluatorFactory"/>
    </function>

    <!-- fn:lower-case($arg  as xs:string?) as  xs:string -->
    <function name="fn:lower-case">
        <param name="arg" type="xs:string?"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnLowerCaseEvaluatorFactory"/>
    </function>

    <!-- fn:matches($input  as xs:string?, $pattern as xs:string)  as xs:boolean -->
    <function name="fn:matches">
        <param name="input" type="xs:string?"/>
        <param name="pattern" type="xs:string"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:matches($input  as xs:string?, $pattern as xs:string, $flags as xs:string)  as xs:boolean -->
    <function name="fn:matches">
        <param name="input" type="xs:string?"/>
        <param name="pattern" type="xs:string"/>
        <param name="flags" type="xs:string"/>
        <return type="xs:boolean"/>
    </function>

    <!-- fn:max($arg as  xs:anyAtomicType*) as xs:anyAtomicType?  -->
    <function name="fn:max">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnMaxScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnMaxAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:max($arg as  xs:anyAtomicType*, $collation as string)  as xs:anyAtomicType?  -->
    <function name="fn:max">
        <param name="arg" type="xs:anyAtomicType*"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:anyAtomicType"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnMaxScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnMaxAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:min($arg as  xs:anyAtomicType*) as xs:anyAtomicType?  -->
    <function name="fn:min">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnMinScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnMinAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:min($arg as  xs:anyAtomicType*, $collation as string)  as xs:anyAtomicType?  -->
    <function name="fn:min">
        <param name="arg" type="xs:anyAtomicType*"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:anyAtomicType"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnMinScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnMinAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:minutes-from-dateTime( $arg as xs:dateTime?)  as xs:integer?  -->
    <function name="fn:minutes-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnMinutesFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:minutes-from-duration( $arg as xs:duration?)  as xs:integer?  -->
    <function name="fn:minutes-from-duration">
        <param name="arg" type="xs:duration?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnMinutesFromDurationScalarEvaluatorFactory"/>
    </function>

    <!-- fn:minutes-from-time( $arg as xs:time?) as  xs:integer?  -->
    <function name="fn:minutes-from-time">
        <param name="arg" type="xs:time?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnMinutesFromTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:month-from-date($arg  as xs:date?) as  xs:integer?  -->
    <function name="fn:month-from-date">
        <param name="arg" type="xs:date?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnMonthFromDateScalarEvaluatorFactory"/>
    </function>

    <!-- fn:month-from-dateTime( $arg as xs:dateTime?)  as xs:integer?  -->
    <function name="fn:month-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnMonthFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:months-from-duration( $arg as xs:duration?)  as xs:integer?  -->
    <function name="fn:months-from-duration">
        <param name="arg" type="xs:duration?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnMonthsFromDurationScalarEvaluatorFactory"/>
    </function>

    <!-- fn:name() as  xs:string -->
    <function name="fn:name" implicit-context="true">
        <return type="xs:string"/>
    </function>

    <!-- fn:name($arg as  node()?) as xs:string -->
    <function name="fn:name">
        <param name="arg" type="node()?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:namespace-uri() as  xs:anyURI -->
    <function name="fn:namespace-uri" implicit-context="true">
        <return type="xs:anyURI"/>
    </function>

    <!-- fn:namespace-uri($arg  as node()?) as  xs:anyURI -->
    <function name="fn:namespace-uri">
        <param name="arg" type="node()?"/>
        <return type="xs:anyURI"/>
    </function>

    <!-- fn:namespace-uri-for-prefix( $prefix as xs:string?, $element as element())  as xs:anyURI?  -->
    <function name="fn:namespace-uri-for-prefix">
        <param name="prefix" type="xs:string?"/>
        <param name="element" type="element()"/>
        <return type="xs:anyURI"/>
    </function>

    <!-- fn:namespace-uri-from-QName( $arg as xs:QName?) as  xs:anyURI?  -->
    <function name="fn:namespace-uri-from-QName">
        <param name="arg" type="xs:QName?"/>
        <return type="xs:anyURI?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.qname.FnNamespaceUriFromQNameScalarEvaluatorFactory"/>
    </function>

    <!-- fn:nilled($arg as  node()?) as xs:boolean?  -->
    <function name="fn:nilled">
        <param name="arg" type="node()?"/>
        <return type="xs:boolean?"/>
    </function>

    <!-- fn:node-name($arg  as node()?) as  xs:QName?  -->
    <function name="fn:node-name">
        <param name="arg" type="node()?"/>
        <return type="xs:QName?"/>
    </function>

    <!-- fn:normalize-space() as  xs:string -->
    <function name="fn:normalize-space" implicit-context="true">
        <return type="xs:string"/>
    </function>

    <!-- fn:normalize-space($arg  as xs:string?) as  xs:string -->
    <function name="fn:normalize-space">
        <param name="arg" type="xs:string?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:normalize-unicode( $arg as xs:string?)  as xs:string -->
    <function name="fn:normalize-unicode">
        <param name="arg" type="xs:string?"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:normalize-unicode( $arg as xs:string?, $normalizationForm as xs:string)  as xs:string -->
    <function name="fn:normalize-unicode">
        <param name="arg" type="xs:string?"/>
        <param name="normalizationForm" type="xs:string"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:not($arg as  item()*) as xs:boolean -->
    <function name="fn:not">
        <param name="arg" type="xs:boolean"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.bool.FnNotScalarEvaluatorFactory"/>
    </function>

    <!-- fn:number() as  xs:double -->
    <function name="fn:number" implicit-context="true">
        <return type="xs:double"/>
    </function>

    <!-- fn:number($arg as  xs:anyAtomicType?) as xs:double -->
    <function name="fn:number">
        <param name="arg" type="xs:anyAtomicType?"/>
        <return type="xs:double"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.node.FnNumberScalarEvaluatorFactory"/>
    </function>

    <!-- fn:one-or-more($arg  as item()*) as  item()+ -->
    <function name="fn:one-or-more">
        <param name="arg" type="item()*"/>
        <return type="item()+"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnOneOrMoreScalarEvaluatorFactory"/>
        <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>
    </function>

    <!-- fn:position() as  xs:integer -->
    <function name="fn:position">
        <return type="xs:integer"/>
    </function>

    <!-- fn:prefix-from-QName( $arg as xs:QName?) as  xs:NCName?  -->
    <function name="fn:prefix-from-QName">
        <param name="arg" type="xs:QName?"/>
        <return type="xs:NCName?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.qname.FnPrefixFromQNameScalarEvaluatorFactory"/>
    </function>

    <!-- fn:QName($paramURI  as xs:string?, $paramQName as xs:string)  as xs:QName -->
    <function name="fn:QName">
        <param name="paramURI" type="xs:string?"/>
        <param name="paramQName" type="xs:string"/>
        <return type="xs:QName"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.qname.FnQNameScalarEvaluatorFactory"/>
    </function>

    <!-- fn:remove($target  as item()*, $position as xs:integer)  as item()* -->
    <function name="fn:remove">
        <param name="target" type="item()*"/>
        <param name="position" type="xs:integer"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnRemoveScalarEvaluatorFactory"/>
    </function>

    <!-- fn:replace($input  as xs:string?, $pattern as xs:string, $replacement as xs:string)  as xs:string -->
    <function name="fn:replace">
        <param name="input" type="xs:string?"/>
        <param name="pattern" type="xs:string"/>
        <param name="replacement" type="xs:string"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:replace($input  as xs:string?, $pattern as xs:string, $replacement as xs:string, $flags as xs:string)  as xs:string -->
    <function name="fn:replace">
        <param name="input" type="xs:string?"/>
        <param name="pattern" type="xs:string"/>
        <param name="replacement" type="xs:string"/>
        <param name="flags" type="xs:string"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:resolve-QName($qname  as xs:string?, $element as element())  as xs:QName?  -->
    <function name="fn:resolve-QName">
        <param name="qname" type="xs:string?"/>
        <param name="element" type="element()"/>
        <return type="xs:QName?"/>
    </function>

    <!-- fn:resolve-uri($relative  as xs:string?) as  xs:anyURI?  -->
    <function name="fn:resolve-uri">
        <param name="relative" type="xs:string?"/>
        <return type="xs:anyURI?"/>
    </function>

    <!-- fn:resolve-uri($relative  as xs:string?, $base as xs:string)  as xs:anyURI?  -->
    <function name="fn:resolve-uri">
        <param name="relative" type="xs:string?"/>
        <param name="base" type="xs:string"/>
        <return type="xs:anyURI?"/>
    </function>

    <!-- fn:reverse($arg as  item()*) as item()* -->
    <function name="fn:reverse">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnReverseScalarEvaluatorFactory"/>
    </function>

    <!-- fn:root() as  node() -->
    <function name="fn:root" implicit-context="true">
        <return type="node()"/>
    </function>

    <!-- fn:root($arg as  node()?) as node()?  -->
    <function name="fn:root">
        <param name="arg" type="node()?"/>
        <return type="node()"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </function>

    <!-- fn:round($arg as  numeric?) as numeric?  -->
    <function name="fn:round">
        <param name="arg" type="xsext:numeric?"/>
        <return type="xsext:numeric?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.numeric.FnRoundScalarEvaluatorFactory"/>
    </function>

    <!-- fn:round-half-to-even( $arg as numeric?) as  numeric?  -->
    <function name="fn:round-half-to-even">
        <param name="arg" type="xsext:numeric?"/>
        <return type="xsext:numeric?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.numeric.FnRoundHalfToEvenScalarEvaluatorFactory"/>
    </function>

    <!-- fn:round-half-to-even( $arg as numeric?, $precision as xs:integer)  as numeric?  -->
    <function name="fn:round-half-to-even">
        <param name="arg" type="xsext:numeric?"/>
        <param name="precision" type="xs:integer"/>
        <return type="xsext:numeric?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.numeric.FnRoundHalfToEvenScalarEvaluatorFactory"/>
    </function>

    <!-- fn:seconds-from-dateTime( $arg as xs:dateTime?)  as xs:decimal?  -->
    <function name="fn:seconds-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:decimal?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnSecondsFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:seconds-from-duration( $arg as xs:duration?)  as xs:decimal?  -->
    <function name="fn:seconds-from-duration">
        <param name="arg" type="xs:duration?"/>
        <return type="xs:decimal?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnSecondsFromDurationScalarEvaluatorFactory"/>
    </function>

    <!-- fn:seconds-from-time( $arg as xs:time?) as  xs:decimal?  -->
    <function name="fn:seconds-from-time">
        <param name="arg" type="xs:time?"/>
        <return type="xs:decimal?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnSecondsFromTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:starts-with($arg1  as xs:string?, $arg2 as xs:string?)  as xs:boolean -->
    <function name="fn:starts-with">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnStartsWithEvaluatorFactory"/>
    </function>

    <!-- fn:starts-with($arg1  as xs:string?, $arg2 as xs:string?, $collation as xs:string)  as xs:boolean -->
    <function name="fn:starts-with">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnStartsWithEvaluatorFactory"/>
    </function>

    <!-- fn:static-base-uri() as  xs:anyURI?  -->
    <function name="fn:static-base-uri">
        <return type="xs:anyURI?"/>
    </function>

    <!-- fn:string() as  xs:string -->
    <function name="fn:string" implicit-context="true">
        <return type="xs:string"/>
    </function>

    <!-- fn:string($arg as  item()?) as xs:string -->
    <function name="fn:string">
        <param name="arg" type="item()?"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnStringScalarEvaluatorFactory"/>
    </function>

    <!-- fn:string-join($arg1  as xs:string*, $arg2 as xs:string)  as xs:string -->
    <function name="fn:string-join">
        <param name="arg1" type="xs:string*"/>
        <param name="arg2" type="xs:string"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnStringJoinEvaluatorFactory"/>
    </function>

    <!-- fn:string-length() as  xs:integer -->
    <function name="fn:string-length" implicit-context="true">
        <return type="xs:integer"/>
    </function>

    <!-- fn:string-length($arg  as xs:string?) as  xs:integer -->
    <function name="fn:string-length">
        <param name="arg" type="xs:string?"/>
        <return type="xs:integer"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnStringLengthEvaluatorFactory"/>
    </function>

    <!-- fn:string-to-codepoints( $arg as xs:string?)  as xs:integer* -->
    <function name="fn:string-to-codepoints">
        <param name="arg" type="xs:string?"/>
        <return type="xs:integer*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnStringToCodepointsEvaluatorFactory"/>
    </function>

    <!-- fn:subsequence($sourceSeq  as item()*, $startingLoc as xs:double)  as item()* -->
    <function name="fn:subsequence">
        <param name="sourceSeq" type="item()*"/>
        <param name="startingLoc" type="xs:double"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnSubsequenceScalarEvaluatorFactory"/>
    </function>

    <!-- fn:subsequence($sourceSeq  as item()*, $startingLoc as xs:double, $length as xs:double)  as item()* -->
    <function name="fn:subsequence">
        <param name="sourceSeq" type="item()*"/>
        <param name="startingLoc" type="xs:double"/>
        <param name="length" type="xs:double"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnSubsequenceScalarEvaluatorFactory"/>
    </function>

    <!-- fn:substring($sourceString  as xs:string?, $startingLoc as xs:double)  as xs:string -->
    <function name="fn:substring">
        <param name="sourceSeq" type="xs:string?"/>
        <param name="startingLoc" type="xs:double"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnSubstringEvaluatorFactory"/>
    </function>

    <!-- fn:substring($sourceString  as xs:string?, $startingLoc as xs:double, $length as xs:double)  as xs:string -->
    <function name="fn:substring">
        <param name="sourceSeq" type="xs:string?"/>
        <param name="startingLoc" type="xs:double"/>
        <param name="length" type="xs:double"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnSubstringEvaluatorFactory"/>
    </function>

    <!-- fn:substring-after($arg1  as xs:string?, $arg2 as xs:string?)  as xs:string -->
    <function name="fn:substring-after">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnSubstringAfterEvaluatorFactory"/>
    </function>

    <!-- fn:substring-after($arg1  as xs:string?, $arg2 as xs:string?, $collation as xs:string)  as xs:string -->
    <function name="fn:substring-after">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnSubstringAfterEvaluatorFactory"/>
    </function>

    <!-- fn:substring-before( $arg1 as xs:string?, $arg2 as xs:string?)  as xs:string -->
    <function name="fn:substring-before">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnSubstringBeforeEvaluatorFactory"/>
    </function>

    <!-- fn:substring-before( $arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string)  as xs:string -->
    <function name="fn:substring-before">
        <param name="arg1" type="xs:string?"/>
        <param name="arg2" type="xs:string?"/>
        <param name="collation" type="xs:string"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnSubstringBeforeEvaluatorFactory"/>
    </function>

    <!-- fn:sum($arg as  xs:anyAtomicType*) as xs:anyAtomicType -->
    <function name="fn:sum">
        <param name="arg" type="xs:anyAtomicType*"/>
        <return type="xs:anyAtomicType"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnSumScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnSumAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:sum($arg as  xs:anyAtomicType*, $zero as xs:anyAtomicType?)  as xs:anyAtomicType?  -->
    <function name="fn:sum">
        <param name="arg" type="xs:anyAtomicType*"/>
        <param name="zero" type="xs:anyAtomicType?"/>
        <return type="xs:anyAtomicType?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.aggregate.FnSumScalarEvaluatorFactory"/>
        <runtime type="aggregate" class="org.apache.vxquery.runtime.functions.aggregate.FnSumAggregateEvaluatorFactory"/>
    </function>

    <!-- fn:timezone-from-date( $arg as xs:date?) as  xs:dayTimeDuration?  -->
    <function name="fn:timezone-from-date">
        <param name="arg" type="xs:date?"/>
        <return type="xs:dayTimeDuration?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnTimezoneFromDateScalarEvaluatorFactory"/>
    </function>

    <!-- fn:timezone-from-dateTime( $arg as xs:dateTime?)  as xs:dayTimeDuration?  -->
    <function name="fn:timezone-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:dayTimeDuration?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnTimezoneFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:timezone-from-time( $arg as xs:time?) as  xs:dayTimeDuration?  -->
    <function name="fn:timezone-from-time">
        <param name="arg" type="xs:time?"/>
        <return type="xs:dayTimeDuration?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnTimezoneFromTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:tokenize($input  as xs:string?, $pattern as xs:string)  as xs:string* -->
    <function name="fn:tokenize">
        <param name="input" type="xs:string?"/>
        <param name="pattern" type="xs:string"/>
        <return type="xs:string*"/>
    </function>

    <!-- fn:tokenize($input  as xs:string?, $pattern as xs:string, $flags as xs:string)  as xs:string* -->
    <function name="fn:tokenize">
        <param name="input" type="xs:string?"/>
        <param name="pattern" type="xs:string"/>
        <param name="flags" type="xs:string"/>
        <return type="xs:string*"/>
    </function>

    <!-- fn:trace($value as  item()*, $label as xs:string)  as item()* -->
    <function name="fn:trace">
        <param name="value" type="item()*"/>
        <param name="label" type="xs:string"/>
        <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>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.trace.FnTraceScalarEvaluatorFactory"/>
    </function>

    <!-- fn:translate($arg  as xs:string?, $mapString as xs:string, $transString as xs:string)  as xs:string -->
    <function name="fn:translate">
        <param name="arg" type="xs:string?"/>
        <param name="mapString" type="xs:string"/>
        <param name="transString" type="xs:string"/>
        <return type="xs:string"/>
    </function>

    <!-- fn:true() as  xs:boolean -->
    <function name="fn:true">
        <return type="xs:boolean"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.bool.FnTrueScalarEvaluatorFactory"/>
    </function>

    <!-- fn:unordered($sourceSeq  as item()*) as  item()* -->
    <function name="fn:unordered">
        <param name="sourceSeq" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnUnorderedScalarEvaluatorFactory"/>
        <property type="DocumentOrder" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.documentorder.DocumentOrderNOPropagationPolicy"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </function>

    <!-- fn:upper-case($arg  as xs:string?) as  xs:string -->
    <function name="fn:upper-case">
        <param name="arg" type="xs:string?"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.strings.FnUpperCaseEvaluatorFactory"/>
    </function>

    <!-- fn:year-from-date($arg  as xs:date?) as  xs:integer?  -->
    <function name="fn:year-from-date">
        <param name="arg" type="xs:date?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnYearFromDateScalarEvaluatorFactory"/>
    </function>

    <!-- fn:year-from-dateTime( $arg as xs:dateTime?)  as xs:integer?  -->
    <function name="fn:year-from-dateTime">
        <param name="arg" type="xs:dateTime?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnYearFromDateTimeScalarEvaluatorFactory"/>
    </function>

    <!-- fn:years-from-duration( $arg as xs:duration?)  as xs:integer?  -->
    <function name="fn:years-from-duration">
        <param name="arg" type="xs:duration?"/>
        <return type="xs:integer?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.datetime.FnYearsFromDurationScalarEvaluatorFactory"/>
    </function>

    <!-- fn:zero-or-one($arg  as item()*) as  item()?  -->
    <function name="fn:zero-or-one">
        <param name="arg" type="item()*"/>
        <return type="item()?"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.sequence.FnZeroOrOneScalarEvaluatorFactory"/>
        <property type="UniqueNodes" class="org.apache.vxquery.compiler.rewriter.rules.propagationpolicies.InputPropertyPropagationPolicy">
            <argument value="0"/>
        </property>
    </function>

    <!-- fn:serialize($data  as item()*) as  xs:string  -->
    <function name="fn:serialize">
        <param name="data" type="item()*"/>
        <return type="xs:string"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.serialize.FnSerializeScalarEvaluatorFactory"/>
    </function>

    <!-- jn:keys($arg as item()*) as xs:string* -->
    <function name="jn:keys">
        <param name="arg" type="item()*"/>
        <return type="xs:string*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.JnKeysScalarEvaluatorFactory"/>
    </function>

    <!-- jn:members($arg as item()*) as item()* -->
    <function name="jn:members">
        <param name="arg" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.JnMembersScalarEvaluatorFactory"/>
    </function>

    <!-- jn:null() as js:null -->
    <function name="jn:null">
        <return type="js:null"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.JnNullScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:descendant-arrays($sequence as item()*) as array()* -->
    <function name="libjn:descendant-arrays">
        <param name="sequence" type="item()*"/>
        <return type="json-item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnDescendantArraysScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:flatten($sequence as item()*) as item()* -->
    <function name="libjn:flatten">
        <param name="sequence" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnFlattenScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:values($sequence as item()*) as item()* -->
    <function name="libjn:values">
        <param name="sequence" type="item()*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnValuesScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:descendant-objects($sequence as item()*) as object()* -->
    <function name="libjn:descendant-objects">
        <param name="sequence" type="item()*"/>
        <return type="object()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnDescendantObjectsScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:descendant-pairs($sequence as item()*) object()* -->
    <function name="libjn:descendant-pairs">
        <param name="sequence" type="item()*"/>
        <return type="object()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnDescendantPairsScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:project($sequence as item()*, $keys as xs:string*) as item()* -->
    <function name="libjn:project">
        <param name="sequence" type="item()*"/>
        <param name="keys" type="xs:string*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnProjectScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:remove-keys($sequence as item()*, $keys as xs:string*) as item()* -->
    <function name="libjn:remove-keys">
        <param name="sequence" type="item()*"/>
        <param name="keys" type="xs:string*"/>
        <return type="item()*"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnRemoveKeysScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:accumulate($sequence as item()*) as object() -->
    <function name="libjn:accumulate">
        <param name="sequence" type="item()*"/>
        <return type="object()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnAccumulateScalarEvaluatorFactory"/>
    </function>

    <!-- libjn:intersect($sequence as item()*) as object() -->
    <function name="libjn:intersect">
        <param name="sequence" type="item()*"/>
        <return type="object()"/>
        <runtime type="scalar" class="org.apache.vxquery.runtime.functions.json.LibjnIntersectScalarEvaluatorFactory"/>
    </function>
</functions>