MacFormat UK 160 - Disc 2/MF_UK_160_2.iso/pc/DiscContent/Trials/oxygen/lib/oxygen.jar/builtin/xqueryFunctions.xml

Extensible Markup Language | 2005-07-21 | 83.8 KB | 1,190 lines

<?xml version="1.0" encoding="UTF-8"?>
<xquery_functions>
    <function name="abs">
        <signature>fn:abs($arg as numeric?) as numeric?</signature>
        <summary>Summary: Returns the absolute value of $arg. If $arg is negative returns -$arg
            otherwise returns $arg. If type of $arg is one of the four numeric types xs:float,
            xs:double, xs:decimal or xs:integer the type of the return is the same as the type of
            $arg. If the type of $arg is a type derived from one of the numeric types, the type of
            the return is the base numeric type.</summary>
    </function>
    <function name="add-dayTimeDuration-to-date">
        <signature>op:add-dayTimeDuration-to-date( $arg1 as xs:date, $arg2 as xdt:dayTimeDuration)
            as xs:date</signature>
        <summary>Summary: Returns the xs:date computed by adding $arg2 to the normalized value of
            $arg1.If $arg2 is negative, then the xs:date returned precedes $arg1.The result has the
            same timezone as arg1. If arg1 has no timezone, the result has no timezone.</summary>
    </function>
    <function name="add-dayTimeDuration-to-dateTime">
        <signature>op:add-dayTimeDuration-to-dateTime( $arg1 as xs:dateTime, $arg2 as
            xdt:dayTimeDuration) as xs:dateTime </signature>
        <summary>Summary: Returns the xs:dateTime computed by adding $arg2 to the normalized value
            of $arg1. If $arg2 is negative, then the result xs:dateTime precedes $arg1. The result
            has the same timezone as arg1. If arg1 has no timezone, the result has no timezone.</summary>
    </function>
    <function name="add-dayTimeDuration-to-time">
        <signature>op:add-dayTimeDuration-to-time( $arg1 as xs:time, $arg2 as xdt:dayTimeDuration)
            as xs:time </signature>
        <summary>Summary: First, the days component in the canonical lexical representation of $arg2
            is set to zero (0) and the value of the resulting xdt:dayTimeDuration is calculated.
            Alternatively, the value modulus 86,400 is used. This value is added to the normalized
            value of $arg1 and the result returned. Note that the xs:time returned may occur in a
            following or preceding day and may be less than $arg1. The result has the same timezone
            as arg1. If arg1 has no timezone, the result has no timezone.</summary>
    </function>
    <function name="add-dayTimeDurations">
        <signature>fn:add-dayTimeDurations( $arg1 as xdt:dayTimeDuration, $arg2 as
            xdt:dayTimeDuration) as xdt:dayTimeDuration </signature>
        <summary>Summary: Returns the result of adding the value of $arg1 to the value of $arg2.
            Backs up the "+" operator on xdt:dayTimeDuration values.</summary>
    </function>
    <function name="add-yearMonthDuration-to-date">
        <signature>fn:add-yearMonthDuration-to-date( $arg1 as xs:date, $arg2 as
            xdt:yearMonthDuration) as xs:date </signature>
        <summary>Summary: Returns the xs:date computed by adding $arg2 to the normalized value of
            $arg1. If $arg2 is negative, then the xs:date returned precedes $arg1. The result has
            the same timezone as arg1. If arg1 has no timezone, the result has no timezone </summary>
    </function>
    <function name="add-yearMonthDuration-to-dateTime">
        <signature>fn:add-yearMonthDuration-to-dateTime( $arg1 as xs:dateTime, $arg2 as
            xdt:yearMonthDuration) as xs:dateTime </signature>
        <summary>Summary: Returns the xs:dateTime computed by adding $arg2 to the normalized value
            of $arg1If $arg2 is negative, then the result xs:dateTime precedes $arg1. The result has
            the same timezone as arg1. If arg1 has no timezone, the result has no timezone.</summary>
    </function>
    <function name="add-yearMonthDurations">
        <signature>fn:add-yearMonthDurations( $arg1 as xdt:yearMonthDuration, $arg2 as
            xdt:yearMonthDuration) as xdt:yearMonthDuration </signature>
        <summary>Summary: Returns the result of adding the value of $arg1 to the value of $arg2.
            Backs up the "+" operator on xdt:yearMonthDuration values.</summary>
    </function>
    <function name="adjust-date-to-timezone">
        <signature>fn:adjust-date-to-timezone($arg as xs:date?) as xs:date?</signature>
        <signature>fn:adjust-date-to-timezone( $arg as xs:date?, $timezone as xdt:dayTimeDuration?)
            as xs:date? </signature>
        <summary>Summary: Adjusts an xs:date value to a specific timezone, or to no timezone at all.
            If $timezone is the empty sequence, returns an xs:date without a timezone. Otherwise,
            returns an xs:date with a timezone. For purposes of timezone adjustment, an xs:date is
            treated as an xs:dateTime with time 00:00:00.</summary>
    </function>
    <function name="adjust-dateTime-to-timezone">
        <signature>fn:adjust-dateTime-to-timezone($arg as xs:dateTime?) as xs:dateTime?</signature>
        <signature>fn:adjust-dateTime-to-timezone( $arg as xs:dateTime?, $timezone as
            xdt:dayTimeDuration?) as xs:dateTime? </signature>
        <summary>Summary: Adjusts an xs:dateTime value to a specific timezone, or to no timezone at
            all. If $timezone is the empty sequence, returns an xs:dateTime without a timezone.
            Otherwise, returns an xs:dateTime with a timezone.</summary>
    </function>
    <function name="adjust-time-to-timezone">
        <signature>fn:adjust-time-to-timezone($arg as xs:time?) as xs:time? </signature>
        <signature>fn:adjust-time-to-timezone( $arg as xs:time?, $timezone as xdt:dayTimeDuration?)
            as xs:time? </signature>
        <summary>Summary: Adjusts an xs:time value to a specific timezone, or to no timezone at all.
            If $timezone is the empty sequence, returns an xs:time without a timezone. Otherwise,
            returns an xs:time with a timezone.</summary>
    </function>
    <function name="anyURI-equal">
        <signature>op:anyURI-equal($arg1 as xs:anyURI, $arg2 as xs:anyURI) as xs:boolean </signature>
        <summary>Summary: Returns true if $arg1 and $arg2 compare equal on a codepoint-by-codepoint
            basis. Otherwise, returns false. This function backs up the "eq" and
            "ne" operators on anyURI.</summary>
    </function>
    <function name="avg">
        <signature>fn:avg($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?</signature>
        <summary>Summary: Returns the average of the values in the input sequence $arg, that is, the
            sum of the values divided by the number of values.</summary>
    </function>
    <function name="base-uri">
        <signature>fn:base-uri($arg as node()?) as xs:anyURI?</signature>
        <summary>Summary: Returns the value of the base-uri property for $arg as defined by the
            accessor function dm:base-uri() for that kind of node.</summary>
        <signature>fn:base-uri() as xs:anyURI?</signature>
        <summary>Summary: This version of the function returns the value of the base-uri property
            from the static context. If the base-uri property is undefined, the empty sequence is returned.</summary>
    </function>
    <function name="base64Binary-equal">
        <signature>op:base64Binary-equal( $value1 as xs:base64Binary, $value2 as xs:base64Binary) as xs:boolean</signature>
        <summary>Summary: Returns true if $value1 and $value2 are of the same length, measured in
            binary octets, and contain the same octets in the same order. Otherwise, returns false.</summary>
    </function>
    <function name="boolean">
        <signature>fn:boolean($arg as item()*) as xs:boolean</signature>
        <summary>Summary: Computes the effective boolean value of the sequence $arg</summary>
    </function>
    <function name="boolean-equal">
        <signature>op:boolean-equal($value1 as xs:boolean, $value2 as xs:boolean) as xs:boolean</signature>
        <summary>Summary: Returns true if both arguments are true or if both arguments are false.
            Returns false if one of the arguments is true and the other argument is false.</summary>
    </function>
    <function name="boolean-greater-than">
        <signature>op:boolean-greater-than($arg1 as xs:boolean, $arg2 as xs:boolean) as xs:boolean</signature>
        <summary>Summary: Returns true if $arg1 is true and $arg2 is false. Otherwise, returns false.</summary>
    </function>
    <function name="boolean-less-than">
        <signature>op:boolean-less-than($arg1 as xs:boolean, $arg2 as xs:boolean) as xs:boolean</signature>
        <summary>Summary: Returns true if $arg1 is false and $arg2 is true. Otherwise, returns false.</summary>
    </function>
    <function name="ceiling">
        <signature>fn:ceiling($arg as numeric?) as numeric?</signature>
        <summary>Summary: Returns the smallest (closest to negative infinity) number with no
            fractional part that is not less than the value of $arg. If type of $arg is one of the
            four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the return
            is the same as the type of $arg. If the type of $arg is a type derived from one of the
            numeric types, the type of the return is the base numeric type.</summary>
    </function>
    <function name="codepoints-to-string">
        <signature>fn:codepoints-to-string($arg as xs:integer*) as xs:string</signature>
        <summary>Creates an xs:string from a sequence of code points. Returns the zero-length string
            if $arg is the empty sequence. If any of the code points in $arg is not a legal XML
            character, an error is raised</summary>
    </function>
    <function name="collection">
        <signature>fn:collection($arg as xs:string?) as node()*</signature>
        <summary>Summary: Takes a xs:string as argument and returns a sequence of nodes obtained by
            interpreting $arg as an xs:anyURI and resolving it according to the mapping specified in
            Available collections. If Available collections provides a mapping from this string to a
            sequence of nodes, the function returns that sequence. If Available collections maps the
            string to an empty sequence, then the function returns an empty sequence. If Available
            collections provides no mapping for the string, an error is raised </summary>
    </function>
    <function name="compare">
        <signature>fn:compare($comparand1 as xs:string?, $comparand2 as xs:string?) as xs:integer?</signature>
        <signature>fn:compare( $comparand1 as xs:string?, $comparand2 as xs:string?, $collation as
            xs:string) as xs:integer? </signature>
        <summary>Summary: Returns -1, 0, or 1, depending on whether the value of the $comparand1 is
            respectively less than, equal to, or greater than the value of $comparand2, according to
            the rules of the collation that is used.</summary>
    </function>
    <function name="concat">
        <signature>fn:concat( $arg1 as xdt:anyAtomicType?, $arg2 as xdt:anyAtomicType?, ... ) as
            xs:string </signature>
        <summary>Summary: Accepts two or more xdt:anyAtomicType arguments and converts them to
            xs:string. Returns the xs:string that is the concatenation of the values of its
            arguments after conversion. If any of the arguments is the empty sequence, the argument
            is treated as the zero-length string.</summary>
    </function>
    <function name="concatenate">
        <signature>op:concatenate($seq1 as item()*, $seq2 as item()*) as item()*</signature>
        <summary>Summary: Returns a sequence consisting of the items in $seq1 followed by the items
            in $seq2. This function backs up the infix operator ",". If either
            sequence is the empty sequence, the other operand is returned.</summary>
    </function>
    <function name="contains">
        <signature>fn:contains($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean</signature>
        <signature>fn:contains( $arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string)
            as xs:boolean </signature>
        <summary>Summary: Returns an xs:boolean indicating whether or not the value of $arg1
            contains (at the beginning, at the end, or anywhere within) at least one sequence of
            collation units that provides a minimal match to the collation units in the value of
            $arg2, according to the collation that is used.</summary>
    </function>
    <function name="count">
        <signature>fn:count($arg as item()*) as xs:integer</signature>
        <summary>Summary: Returns the number of items in the value of $arg.</summary>
    </function>
    <function name="current-date">
        <signature>fn:current-date() as xs:date </signature>
        <summary>Summary: Returns xs:date(fn:current-dateTime()). This is a xs:date (with timezone)
            that is current at some time during the evaluation of a query or transformation in which
            fn:current-date() is executed. This function is ·stable·. The precise instant during the
            query or transformation represented by the value of fn:current-date() is ·implementation dependent·.</summary>
    </function>
    <function name="current-dateTime">
        <signature>fn:current-dateTime() as xs:dateTime</signature>
        <summary>Summary: Returns the xs:dateTime (with timezone) from the dynamic context.This is a
            xs:dateTime that is current at some time during the evaluation of a query or
            transformation in which fn:current-dateTime() is executed. This function is ·stable·.
            The precise instant during the query or transformation represented by the value of
            fn:current-dateTime() is ·implementation dependent·.</summary>
    </function>
    <function name="current-time">
        <signature>fn:current-time() as xs:time</signature>
        <summary>Summary: Returns xs:time(fn:current-dateTime()). This is axs:time (with timezone)
            that is current at some time during the evaluation of a query or transformation in which
            fn:current-time() is executed. This function is ·stable·. The precise instant during the
            query or transformation represented by the value of fn:current-time() is ·implementation dependent·.</summary>
    </function>
    <function name="data">
        <signature>fn:data($arg as item()*) as xdt:anyAtomicType*</signature>
        <summary>Summary: fn:data takes a sequence of items and returns a sequence of atomic values.</summary>
    </function>
    <function name="date-equal">
        <signature>op:date-equal($arg1 as xs:date, $arg2 as xs:date) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="date-greater-than">
        <signature>op:date-greater-than($arg1 as xs:date, $arg2 as xs:date) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is greater than
            the normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="date-less-than">
        <signature>op:date-less-than($arg1 as xs:date, $arg2 as xs:date) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is less than the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="deep-equal">
        <signature>fn:deep-equal($parameter1 as item()*, $parameter2 as item()*) as xs:boolean</signature>
        <signature>fn:deep-equal( $parameter1 as item()*, $parameter2 as item()*, $collation as
            string) as xs:boolean </signature>
        <summary>Summary: The function assesses whether two sequences are deep-equal to each other.
            To be deep-equal, they must contain items that are pairwise deep-equal; and for two
            items to be deep-equal, they must either by atomic values that compare equal, or nodes
            of the same kind, with the same name, whose children are deep-equal. This is defined in
            more detail below. The $collation argument identifies a collation which is used at all
            levels of recursion when strings are compared (but not when names are compared).</summary>
    </function>
    <function name="default-collation">
        <signature>fn:default-collation() as xs:string</signature>
        <summary>Summary: Returns the value of the default collation property from the static context.</summary>
    </function>
    <function name="distinct-values">
        <signature>fn:distinct-values($arg as xdt:anyAtomicType*) as xdt:anyAtomicType*</signature>
        <signature>fn:distinct-values( $arg as xdt:anyAtomicType*, $collation as xs:string) as
            xdt:anyAtomicType* </signature>
        <summary>Summary: Returns the sequence that results from removing from $arg all but one of a
            set of values that are eq to one other. Values that cannot be compared, i.e. the eq
            operator is not defined for their types, are considered to be distinct. Values of type
            xdt:untypedAtomic are compared as if they were of type xs:string. The order in which the
            sequence of values is returned is ·implementation dependent·.</summary>
    </function>
    <function name="divide-dayTimeDuration">
        <signature>op:divide-dayTimeDuration( $arg1 as xdt:dayTimeDuration, $arg2 as xs:double) as
            xdt:dayTimeDuration </signature>
        <summary>Summary: Returns the result of dividing the value of $arg1 by $arg2.</summary>
        <signature>op:divide-dayTimeDuration( $arg1 as xdt:dayTimeDuration, $arg2 as
            xdt:dayTimeDuration) as xs:decimal </signature>
        <summary>Summary: Returns the result of dividing the value of $arg1 by $arg2. Since the
            values of both operands are decimals, the semantics of the division is identical to
            op:numeric-divide with xs:decimal operands.</summary>
    </function>
    <function name="divide-yearMonthDuration">
        <signature>op:divide-yearMonthDuration( $arg1 as xdt:yearMonthDuration, $arg2 as xs:double)
            as xdt:yearMonthDuration </signature>
        <summary>Summary: Returns the result of dividing the value of $arg1 by $arg2. The result is
            rounded to the nearest month. For a value v, 0 <= v < 0.5 rounds to 0; 0.5
            <= v < 1.0 rounds to 1.</summary>
        <signature>op:divide-yearMonthDuration( $arg1 as xdt:yearMonthDuration, $arg2 as
            xdt:yearMonthDuration) as xs:decimal </signature>
        <summary>Summary: Returns the result of dividing the value of $arg1 by $arg2. Since the
            values of both operands are integers, the semantics of the division is identical to
            op:numeric-divide with xs:integer operands.</summary>
    </function>
    <function name="doc">
        <signature>fn:doc($uri as xs:string?) as document-node()?</signature>
        <summary>Summary: Retrieves a document using an xs:anyURI supplied as an xs:string. If $uri
            is not a valid xs:anyURI, an error is raised [invalid argument to fn:doc]. If it is a
            relative URI Reference, it is resolved relative to the value of the base URI property
            from the static context. The resulting absolute URI Reference is cast to an xs:string.
            If the Available documents provides a mapping from this string to a document node, the
            function returns that document node. If the Available documents maps the string to an
            empty sequence, then the function returns an empty sequence. If the Available documents
            provides no mapping for the string, an error is raised [invalid argument to fn:doc].</summary>
    </function>
    <function name="document-uri">
        <signature>fn:document-uri($arg as node()?) as xs:anyURI?</signature>
        <summary>Summary: Returns the value of the document-uri property for $arg as defined by the
            accessor function.</summary>
    </function>
    <function name="empty">
        <signature>fn:empty($arg as item()*) as xs:boolean</signature>
        <summary>Summary: If the value of $arg is the empty sequence, the function returns true;
            otherwise, the function returns false.</summary>
    </function>
    <function name="ends-with">
        <signature>fn:ends-with($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean</signature>
        <signature>fn:ends-with( $arg1 as xs:string?, $arg2 as xs:string?, $collation as xs:string)
            as xs:boolean </signature>
        <summary>Summary: Returns an xs:boolean indicating whether or not the value of $arg1 ends
            with a sequence of collation units that provides a minimal match to the collation units
            of M$arg2 according to the collation that is used.</summary>
    </function>
    <function name="error">
        <signature>fn:error() as none</signature>
        <signature>fn:error($error as xs:QName) as none</signature>
        <signature>fn:error($error as xs:QName, $description as xs:string) as none</signature>
        <signature>fn:error( $error as xs:QName, $description as xs:string, $error-object as item()*)</signature>
        <summary>Summary: The fn:error function causes the evaluation of the outermost XQuery or
            transformation to stop. While this function never returns a value, it will cause a URI
            that identifies the error to be returned to the external processing environment.</summary>
    </function>
    <function name="escape-uri">
        <signature>fn:escape-uri( $uri-part as xs:string?, $escape-reserved as xs:boolean) as
            xs:string </signature>
        <summary>Summary: This function applies the URI escaping rules defined in section 2 of [RFC
            2396] as amended by [RFC 2732], with one exception, to the string supplied as $uri-part,
            which typically represents all or part of a URI. The effect of the function is to escape
            a set of identified characters in the string. Each such character is replaced in the
            string by an escape sequence, which is formed by encoding the character as a sequence of
            octets in UTF-8, and then representing each of these octets in the form %HH, where HH is
            the hexadecimal representation of the octet.</summary>
    </function>
    <function name="exactly-one">
        <signature>fn:exactly-one($arg as item()*) as item()</signature>
        <summary>Summary: Returns $arg if it contains exactly one item. Otherwise, raises an error
            [fn:exactly-one called with a sequence containing zero or more than one item]. The type
            of the result depends on the type of $arg.</summary>
    </function>
    <function name="except">
        <signature>op:except($parameter1 as node()*, $parameter2 as node()*) as node()*</signature>
        <summary>Summary: Constructs a sequence containing every node that occurs in the value of
            $parameter1, but not in the value of $parameter2, eliminating duplicate nodes. Nodes are
            returned in document order.</summary>
    </function>
    <function name="exists">
        <signature>fn:exists($arg as item()*) as xs:boolean</signature>
        <summary>Summary: If the value of $arg is not the empty sequence, the function returns true;
            otherwise, the function returns false</summary>
    </function>
    <function name="expanded-QName">
        <signature>fn:expanded-QName($paramURI as xs:string?, $paramLocal as xs:string) as xs:QName</signature>
        <summary>Summary: Returns an xs:QName with the namespace URI given in $paramURI and the
            local name in $paramLocal. If $paramURI is the empty string or the empty sequence, it
            represents "no namespace". If $paramLocal does not have the correct
            lexical form for xs:NCName an error is raised [invalid lexical value].</summary>
    </function>
    <function name="false">
        <signature>fn:false() as xs:boolean</signature>
        <summary>Summary: Returns the xs:boolean value false. Equivalent to xs:boolean("0").</summary>
    </function>
    <function name="floor">
        <signature>fn:floor($arg as numeric?) as numeric?</signature>
        <summary>Summary: Returns the largest (closest to positive infinity) number with no
            fractional part that is not greater than the value of $arg. If type of $arg is one of
            the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the
            return is the same as the type of $arg. If the type of $arg is a type derived from one
            of the numeric types, the type of the return is the base numeric type</summary>
    </function>
    <function name="gDay-equal">
        <signature>op:gDay-equal($arg1 as xs:gDay, $arg2 as xs:gDay) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="gMonth-equal">
        <signature>op:gMonth-equal($arg1 as xs:gMonth, $arg2 as xs:gMonth) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="gMonthDay-equal">
        <signature>op:gMonthDay-equal($arg1 as xs:gMonthDay, $arg2 as xs:gMonthDay) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="gYear-equal">
        <signature>op:gYear-equal($arg1 as xs:gYear, $arg2 as xs:gYear) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="gYearMonth-equal">
        <signature>op:gYearMonth-equal( $arg1 as xs:gYearMonth, $arg2 as xs:gYearMonth) as
            xs:boolean </signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="hexBinary-equal">
        <signature>op:hexBinary-equal( $value1 as xs:hexBinary, $value2 as xs:hexBinary) as
            xs:boolean </signature>
        <summary>Summary: Returns true if $value1 and $value2 are of the same length, measured in
            binary octets, and contain the same octets in the same order. Otherwise, returns false.</summary>
    </function>
    <function name="hours-from-dateTime">
        <signature>fn:hours-from-dateTime($arg as xs:dateTime?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer between 0 and 23, both inclusive, representing the
            hours component in the localized value of $arg. If $arg is the empty sequence, returns
            the empty sequence.</summary>
    </function>
    <function name="hours-from-duration">
        <signature>fn:hours-from-duration($arg as xdt:dayTimeDuration?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer representing the hours component in the canonical
            lexical representation of the value of $arg. The result may be negative. If $arg is the
            empty sequence, returns the empty sequence</summary>
    </function>
    <function name="hours-from-time">
        <signature>fn:hours-from-time($arg as xs:time?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer between 0 and 23, both inclusive, representing the
            value of the hours component in the localized value of $arg. If $arg is the empty
            sequence, returns the empty sequence.</summary>
    </function>
    <function name="id">
        <signature>fn:id($arg as xs:string*) as element()*</signature>
        <signature>fn:id($arg as xs:string*, $node as node()) as element()*</signature>
        <summary>Summary: Returns the sequence of element nodes with xs:ID values matching the
            values of one or more of the xs:IDREF values supplied in $arg</summary>
    </function>
    <function name="idref">
        <signature>fn:idref($arg as xs:string*) as node()*</signature>
        <signature>fn:idref($arg as xs:string*, $node as node()) as node()*</signature>
        <summary>Summary: Returns the nodes that have xs:IDREF values that reference one or more of
            the xs:ID values specified in $arg. This function allows reverse navigation from IDs to xs:IDREFs.</summary>
    </function>
    <function name="implicit-timezone">
        <signature>fn:implicit-timezone() as xdt:dayTimeDuration?</signature>
        <summary>Summary: Returns the value of the implicit timezone property from the evaluation
            context. Returns the empty sequence if the implicit timezone is undefined.</summary>
    </function>
    <function name="in-scope-prefixes">
        <signature>fn:in-scope-prefixes($element as element()) as xs:string*</signature>
        <summary>Summary: Returns the prefixes of the in-scope namespaces for $element. For
            namespaces that have a prefix, it returns the prefix as an xs:NCName. For the default
            namespace, which has no prefix, it returns the zero-length string.</summary>
    </function>
    <function name="index-of">
        <signature>fn:index-of( $seqParam as xdt:anyAtomicType*, $srchParam as xdt:anyAtomicType) as
            xs:integer* </signature>
        <signature>fn:index-of( $seqParam as xdt:anyAtomicType*, $srchParam as xdt:anyAtomicType,
            $collation as xs:string) as xs:integer* </signature>
        <summary>Summary: Returns a sequence of positive integers giving the positions within the
            sequence $seqParam of items that are equal to $srchParam.</summary>
    </function>
    <function name="insert-before">
        <signature>fn:insert-before( $target as item()*, $position as xs:integer, $inserts as
            item()*) as item()* </signature>
        <summary>Summary: Returns a new sequence constructed from the value of $target with the
            value of $inserts inserted at the position specified by the value of $position. (The
            value of $target is not affected by the sequence construction.) If $target is the empty
            sequence, $inserts is returned. If $inserts is the empty sequence, $target is returned.
            The value returned by the function consists of all items of $target whose index is less
            than $position, followed by all items of $inserts, followed by the remaining elements of
            $target, in that sequence. If $position is less than one (1), the first position, the
            effective value of $position is one (1). If $position is greater than the number of
            items in $target, then the effective value of $position is equal to the number of items
            in $target plus 1.</summary>
    </function>
    <function name="intersect">
        <signature>op:intersect($parameter1 as node()*, $parameter2 as node()*) as node()*</signature>
        <summary>Summary: Constructs a sequence containing every node that occurs in the values of
            both $parameter1 and $parameter2, eliminating duplicate nodes. Nodes are returned in
            document order. If either operand is the empty sequence, the empty sequence is returned</summary>
    </function>
    <function name="is-same-node">
        <signature>op:is-same-node($parameter1 as node(), $parameter2 as node()) as xs:boolean</signature>
        <summary>Summary: If the node identified by the value of $parameter1 is the same node as the
            node identified by the value of $parameter2 (that is, the two nodes have the same
            identity), then the function returns true; otherwise, the function returns false. This
            function backs up the "is" operator on nodes.</summary>
    </function>
    <function name="lang">
        <signature>fn:lang($testlang as xs:string?) as xs:boolean</signature>
        <signature>fn:lang($testlang as xs:string?, $node as node()) as xs:boolean</signature>
        <summary>Summary: This function tests whether the language of $node, or the context node if
            the second argument is omitted, as specified by xml:lang attributes is the same as, or
            is a sublanguage of, the language specified by $testlang. The language of the argument
            node, or the context node if the second argument is omitted, is determined by the value
            of the xml:lang attribute on the node, or, if the node has no such attribute, by the
            value of the xml:lang attribute on the nearest ancestor of the node that has an xml:lang
            attribute. If there is no such ancestor, then the function returns false</summary>
    </function>
    <function name="last">
        <signature>fn:last() as xs:integer</signature>
        <summary>Summary: Returns an xs:integer indicating the number of items in the sequence of
            items currently being processed. If the context item is undefined, an error is raised
            [undefined context item].</summary>
    </function>
    <function name="local-name">
        <signature>fn:local-name() as xs:string</signature>
        <signature>fn:local-name($arg as node()?) as xs:string</signature>
        <summary>Summary: Returns the local part of the name of $arg as an xs:string that will
            either be the zero-length string or will have the lexical form of an xs:NCName.</summary>
    </function>
    <function name="local-name-from-QName">
        <signature>fn:local-name-from-QName($arg as xs:QName?) as xs:NCNAME?</signature>
        <summary>Summary: Returns an xs:NCNAME representing the local part of $arg. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="lower-case">
        <signature>fn:lower-case($arg as xs:string?) as xs:string</signature>
        <summary>Summary, returns the value of $srcval after translating every character to its
            lower-case correspondent. Every character that does not have an lower-case correspondent
            is included in the returned value in its original form. If the value of
            $arg is the empty sequence, the zero-length string is returned.</summary>
    </function>
    <function name="matches">
        <signature>fn:matches($input as xs:string?, $pattern as xs:string) as xs:boolean</signature>
        <signature>fn:matches( $input as xs:string?, $pattern as xs:string, $flags as xs:string) as
            xs:boolean </signature>
        <summary>Summary: The function returns true if $input matches the regular expression
            supplied as $pattern as influenced by the value of $flags, if present; otherwise, it
            returns false.</summary>
    </function>
    <function name="max">
        <signature>fn:max($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?</signature>
        <signature>fn:max($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?</signature>
        <summary>Summary: Selects an item from the input sequence $arg whose value is greater than
            or equal to the value of every other item in the input sequence. If there are two or
            more such items, then the specific item whose value is returned is ·implementation dependent·.</summary>
    </function>
    <function name="min">
        <signature>fn:min($arg as xdt:anyAtomicType*) as xdt:anyAtomicType?</signature>
        <signature>fn:min($arg as xdt:anyAtomicType*, $collation as string) as xdt:anyAtomicType?</signature>
        <summary>Summary: selects an item from the input sequence $arg whose value is less than or
            equal to the value of every other item in the input sequence. If there are two or more
            such items, then the specific item whose value is returned is ·implementation dependent·.</summary>
    </function>
    <function name="minutes-from-dateTime">
        <signature>fn:minutes-from-dateTime($arg as xs:dateTime?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer value between 0 and 59, both inclusive, representing
            the minute component in the localized value of $arg. If $arg is the empty sequence,
            returns the empty sequence.</summary>
    </function>
    <function name="minutes-from-duration">
        <signature>fn:minutes-from-duration($arg as xdt:dayTimeDuration?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer representing the minutes component in the canonical
            lexical representation of the value of $arg. The result may be negative. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="minutes-from-time">
        <signature>fn:minutes-from-time($arg as xs:time?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer value between 0 to 59, both inclusive, representing
            the value of the minutes component in the localized value of $arg. If $arg is the empty
            sequence, returns the empty sequence.</summary>
    </function>
    <function name="month-from-date">
        <signature>fn:month-from-date($arg as xs:date?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer between 1 and 12, both inclusive, representing the
            month component in the localized value of $arg. If $arg is the empty sequence, returns
            the empty sequence.</summary>
    </function>
    <function name="month-from-dateTime">
        <signature>fn:month-from-dateTime($arg as xs:dateTime?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer between 1 and 12, both inclusive, representing the
            month component in the localized value of $arg. If $arg is the empty sequence, returns
            the empty sequence.</summary>
    </function>
    <function name="months-from-duration">
        <signature>fn:months-from-duration($arg as xdt:yearMonthDuration?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer representing the months component in the canonical
            lexical representation of the value of $arg. The result may be negative. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="multiply-dayTimeDuration">
        <signature>op:multiply-dayTimeDuration( $arg1 as xdt:dayTimeDuration, $arg2 as xs:double) as
            xdt:dayTimeDuration </signature>
        <summary>Summary: Returns the result of multiplying the value of $arg1 by $arg2.</summary>
    </function>
    <function name="multiply-yearMonthDuration">
        <signature>op:multiply-yearMonthDuration( $arg1 as xdt:yearMonthDuration, $arg2 as
            xs:double) as xdt:yearMonthDuration </signature>
        <summary>Summary: Returns the result of multiplying the value of $arg1 by $arg2. The result
            is rounded to the nearest month. For a value v, 0 <= v < 0.5 rounds to 0;
            0.5 <= v < 1.0 rounds to 1.</summary>
    </function>
    <function name="name">
        <signature>fn:name() as xs:string</signature>
        <signature>fn:name($arg as node()?) as xs:string</signature>
        <summary>Summary: Returns the name of a node, as an xs:string that is either the zero-length
            string, or has the lexical form of an xs:QName.</summary>
    </function>
    <function name="namespace-uri">
        <signature>fn:namespace-uri() as xs:anyURI</signature>
        <signature>fn:namespace-uri($arg as node()?) as xs:anyURI</signature>
        <summary>Summary: Returns the namespace URI of the QName of $arg as a xs:string.</summary>
    </function>
    <function name="namespace-uri-for-prefix">
        <signature>fn:namespace-uri-for-prefix( $prefix as xs:string, $element as element()) as
            xs:anyURI? </signature>
        <summary>Summary: Returns the namespace URI of one of the in-scope namespaces for $element,
            identified by its namespace prefix.</summary>
    </function>
    <function name="namespace-uri-from-QName">
        <signature>fn:namespace-uri-from-QName($arg as xs:QName?) as xs:anyURI?</signature>
        <summary>Summary: Returns the namespace URI for $arg as an xs:string. If $arg is the empty
            sequence, the empty sequence is returned. If $arg is in no namespace, the zero-length
            string is returned.</summary>
    </function>
    <function name="nilled">
        <signature> fn:nilled($arg as node()) as xs:boolean? </signature>
        <summary> Summary: Returns an xs:boolean indicating whether the argument node is
            "nilled". If the argument is not an element node, returns the empty
            sequence. </summary>
    </function>
    <function name="node-after">
        <signature>op:node-after($parameter1 as node(), $parameter2 as node()) as xs:boolean</signature>
        <summary>Summary: If the node identified by the value of $parameter1 occurs in document
            order after the node identified by the value of $parameter2, this function returns true;
            otherwise, it returns false.</summary>
    </function>
    <function name="node-before">
        <signature>op:node-before($parameter1 as node(), $parameter2 as node()) as xs:boolean</signature>
        <summary>Summary: If the node identified by the value of $parameter1 occurs in document
            order before the node identified by the value of $parameter2, this function returns
            true; otherwise, it returns false.</summary>
    </function>
    <function name="node-name">
        <signature> fn:node-name($arg as node()?) as xs:QName? </signature>
        <summary> Summary: Returns an expanded-QName for node kinds that can have names. For other
            kinds of nodes it returns the empty sequence. If $arg is the empty sequence, the empty
            sequence is returned. </summary>
    </function>
    <function name="normalize-space">
        <signature>fn:normalize-space() as xs:string</signature>
        <signature>fn:normalize-space($arg as xs:string?) as xs:string</signature>
        <summary>Summary: Returns the value of $arg with whitespace normalized by stripping leading
            and trailing whitespace and replacing sequences of one or more than one whitespace
            character with a single space, #x20.</summary>
    </function>
    <function name="normalize-unicode">
        <signature>fn:normalize-unicode($arg as xs:string?) as xs:string</signature>
        <signature>fn:normalize-unicode( $arg as xs:string?, $normalizationForm as xs:string) as
            xs:string </signature>
        <summary>Summary: Returns the value of $arg normalized according to the normalization
            criteria for a normalization form identified by the value of $normalizationForm. The
            effective value of the $normalizationForm is computed by removing leading and trailing
            blanks, if present, and converting to upper case.</summary>
    </function>
    <function name="not">
        <signature>fn:not($arg as item()*) as xs:boolean</signature>
        <summary>Summary: $arg is first reduced to an effective boolean value by applying the
            fn:boolean() function. Returns true if the effective boolean value is false, and false
            if the effective boolean value is true.</summary>
    </function>
    <function name="NOTATION-equal">
        <signature>op:NOTATION-equal($arg1 as xs:NOTATION, $arg2 as xs:NOTATION) as xs:boolean</signature>
        <summary>Summary: Returns true if $arg1 and $arg2 compare equal on a codepoint-by-codepoint
            basis. Else returns false. This function backs up the "eq" and
            "ne" operators on xs:NOTATION values.</summary>
    </function>
    <function name="number">
        <signature>fn:number() as xs:double</signature>
        <signature>fn:number($arg as xdt:anyAtomicType?) as xs:double</signature>
        <summary>Summary: Returns the value indicated by $arg or, if $arg is not specified, the
            context item after atomization, converted to an xs:double. If $arg or the context item
            cannot be converted to an xs:double, the xs:double value NaN is returned. If the context
            item is undefined an error is raised: [undefined context item].</summary>
    </function>
    <function name="numeric-add">
        <signature>op:numeric-add($arg1 as numeric, $arg2 as numeric) as numeric</signature>
        <summary>Summary: Backs up the "+" operator and returns the arithmetic sum
            of its operands: ($arg1 + $arg2).</summary>
    </function>
    <function name="numeric-divide">
        <signature>op:numeric-divide($arg1 as numeric, $arg2 as numeric) as numeric</signature>
        <summary>Summary: Backs up the "div" operator and returns the arithmetic
            quotient of its operands: ($arg1 div $arg2). As a special case, if the types of both
            $arg1 and $arg2 are xs:integer, then the return type is xs:decimal.</summary>
    </function>
    <function name="numeric-equal">
        <signature>op:numeric-equal($arg1 as numeric, $arg2 as numeric) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the value of $arg1 is equal to the value of
            $arg2. For xs:float and xs:double values, positive zero and negative zero compare equal.
            NaN does not equal itself.</summary>
    </function>
    <function name="numeric-greater-than">
        <signature>op:numeric-greater-than($arg1 as numeric, $arg2 as numeric) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if $arg1 is greater than $arg2. For xs:float and
            xs:double values, positive infinity is greater than all other non-NaN values; negative
            infinity is less than all other non-NaN values. If $arg1 or $arg2 is NaN, the function
            returns false.</summary>
    </function>
    <function name="numeric-integer-divide">
        <signature>op:numeric-integer-divide( $arg1 as xs:numeric, $arg2 as xs:numeric) as
            xs:integer </signature>
        <summary>Summary: This function backs up the "idiv" operator and performs
            an integer division: that is, it divides the first argument by the second, and returns
            the integer obtained by truncating the fractional part of the result. The division is
            performed so that the sign of the fractional part is the same as the sign of the
            dividend. If the dividend, $arg1, is not evenly divided by the divisor, $arg2, then the
            quotient is the xs:integer value obtained, ignoring (truncating) any remainder that
            results from the division (that is, no rounding is performed). Thus, the semantics
            "$a idiv $b" are equivalent to "($a div $b) cast as
            xs:integer" except for error situations. If the divisor is zero, then an error
            is raised [division by zero].</summary>
    </function>
    <function name="numeric-less-than">
        <signature>op:numeric-less-than($arg1 as numeric, $arg2 as numeric) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if $arg1 is less than $arg2. For xs:float and
            xs:double values, positive infinity is greater than all other non-NaN values; negative
            infinity is less than all other non-NaN values. If $arg1 or $arg2 is NaN, the function
            returns false.</summary>
    </function>
    <function name="numeric-mod">
        <signature>op:numeric-mod($arg1 as numeric, $arg2 as numeric) as numeric</signature>
        <summary>Summary: Backs up the "mod" operator. Informally, this function
            returns the remainder resulting from dividing $arg1, the dividend, by $arg2, the
            divisor. The operation a mod b for operands that are xs:integer or xs:decimal, or types
            derived from them, produces a result such that (a idiv b)*b+(a mod b) is equal to a and
            the magnitude of the result is always less than the magnitude of b. This identity holds
            even in the special case that the dividend is the negative integer of largest possible
            magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this
            rule that the sign of the result is the sign of the dividend. For xs:integer and
            xs:decimal operands, if $arg2 is zero, then an error is raised [division by zero].</summary>
    </function>
    <function name="numeric-multiply">
        <signature>op:numeric-multiply($arg1 as numeric, $arg2 as numeric) as numeric</signature>
        <summary>Summary: Backs up the "*" operator and returns the arithmetic
            product of its operands: ($arg1 * $arg2).</summary>
    </function>
    <function name="numeric-subtract">
        <signature>op:numeric-subtract($arg1 as numeric, $arg2 as numeric) as numeric</signature>
        <summary>Summary: Backs up the "-" operator and returns the arithmetic
            difference of its operands: ($arg1 - $arg2).</summary>
    </function>
    <function name="numeric-unary-minus">
        <signature>op:numeric-unary-minus($arg as numeric) as numeric</signature>
        <summary>Summary: Backs up the unary "-" operator and returns its operand
            with the sign reversed: (- $arg). If $arg is positive, its negative is returned; if it
            is negative, its positive is returned.</summary>
    </function>
    <function name="numeric-unary-plus">
        <signature>op:numeric-unary-plus($arg as numeric) as numeric</signature>
        <summary>Summary: Backs up the unary "+" operator and returns its operand
            with the sign unchanged: (+ $arg). Semantically, this operation performs no operation.</summary>
    </function>
    <function name="one-or-more">
        <signature>fn:one-or-more($arg as item()*) as item()+</signature>
        <summary>Summary: Returns $arg if it contains one or more items. Otherwise, raises an error
            [fn:one-or-more called with a sequence containing no items]. The type of the result
            depends on the type of $arg.</summary>
    </function>
    <function name="position">
        <signature>fn:position() as xs:integer</signature>
        <summary>Summary: Returns an xs:integer indicating the position of the context item within
            the sequence of items currently being processed. If the context item is undefined, an
            error is raised [undefined context item].</summary>
    </function>
    <function name="QName-equal">
        <signature>op:QName-equal($arg1 as xs:QName, $arg2 as xs:QName) as xs:boolean</signature>
        <summary>Summary: Returns true if the namespace URIs of $arg1 and $arg2 are equal and the
            local names of $arg1 and $arg2 are identical on a codepoint-by-codepoint basis.
            Otherwise, returns false.</summary>
    </function>
    <function name="remove">
        <signature>fn:remove($target as item()*, $position as xs:integer) as item()*</signature>
        <summary>Summary: Returns a new sequence constructed from the value of $target with the item
            at the position specified by the value of $position removed.</summary>
    </function>
    <function name="replace">
        <signature>fn:replace( $input as xs:string?, $pattern as xs:string, $replacement as
            xs:string) as xs:string </signature>
        <signature>fn:replace( $input as xs:string?, $pattern as xs:string, $replacement as
            xs:string, $flags as xs:string) as xs:string </signature>
        <summary>Summary: The function returns the xs:string that is obtained by replacing each
            non-overlapping substring of $input that matches the given $pattern with an occurrence
            of the $replacement string.</summary>
    </function>
    <function name="resolve-QName">
        <signature>fn:resolve-QName($qname as xs:string?, $element as element()) as xs:QName?</signature>
        <summary>Summary: Returns an xs:QName value (that is, an expanded QName) by taking an
            xs:string that has the lexical form of an xs:QName (a string in the form
            "prefix:local-name" or "local-name") and resolving
            it using the in-scope namespaces for a given element. If $qname does not have the
            correct lexical form for xs:QName an error is raised [invalid lexical value]. If $qname
            is the empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="resolve-uri">
        <signature>fn:resolve-uri($relative as xs:string?) as xs:anyURI?</signature>
        <signature>fn:resolve-uri($relative as xs:string?, $base as xs:string) as xs:anyURI?</signature>
        <summary>Summary: If $relative is a relative URI reference, the first form of this function
            resolves it against the value of the base-uri property from the static context. If
            $relative is an absolute URI reference , it is returned unchanged. If the base-uri
            property is not initialized in the static context an error is raised [base uri not
            defined in the static context]. The second form of this function expects $base to be an
            absolute URI and $relative to be an absolute or a relative URI reference as defined in
            [RFC 2396]. If $relative is a relative URI reference, it is resolved against the
            base-uri, $base, and the resulting absolute URI reference is returned. If $relative is
            an absolute URI reference, it is returned unchanged. If $base is not an absolute URI, an
            error is raised [base uri argument to fn:resolve-uri is not an absolute uri]. If
            $relative or $base is not a valid xs:anyURI an error is raised [invalid argument to
            fn:resolve-uri()]. If $relative is the empty sequence, the empty sequence is returned.</summary>
    </function>
    <function name="reverse">
        <signature>fn:reverse($arg as item()*) as item()*</signature>
        <summary>Summary: Reverses the order of items in a sequence. If $arg is the empty sequence,
            the empty sequence is returned.</summary>
    </function>
    <function name="root">
        <signature>fn:root() as node()</signature>
        <signature>fn:root($arg as node()?) as node()?</signature>
        <summary>Summary: Returns the root of the tree to which $arg belongs. This will usually, but
            not necessarily, be a document node. If $arg is the empty sequence, the empty sequence
            is returned. If $arg is a document node, $arg is returned.</summary>
    </function>
    <function name="round">
        <signature>fn:round($arg as numeric?) as numeric?</signature>
        <summary>Summary: Returns the number with no fractional part that is closest to the
            argument. If there are two such numbers, then the one that is closest to positive
            infinity is returned. More formally, fn:round(x) produces the same result as
            fn:floor(x+0.5). If type of $arg is one of the four numeric types xs:float, xs:double,
            xs:decimal or xs:integer the type of the return is the same as the type of $arg. If the
            type of $arg is a type derived from one of the numeric types, the type of the return is
            the base numeric type. For xs:float and xs:double arguments, if the argument is positive
            zero (+0), then positive zero (+0) is returned. If the argument is negative zero (-0),
            then negative zero (-0) is returned. If the argument is less than zero (0), but greater
            than or equal to -0.5, then negative zero (-0) is returned.</summary>
    </function>
    <function name="fn:round-half-to-even">
        <signature>fn:round-half-to-even($arg as numeric?) as numeric?</signature>
        <signature>fn:round-half-to-even($arg as numeric?, $precision as xs:integer) as numeric?</signature>
        <summary>Summary: The value returned is the nearest (that is, numerically closest) numeric
            to $arg that is a multiple of ten to the power of minus $precision. If two such values
            are equally near (e.g. if the fractional part in $arg is exactly .500...), returns the
            one whose least significant digit is even. If type of $arg is one of the four numeric
            types xs:float, xs:double, xs:decimal or xs:integer the type of the return is the same
            as the type of $arg. If the type of $arg is a type derived from one of the numeric
            types, the type of the return is the base numeric type. The first signature of this
            function produces the same result as the second signature with $precision=0. For
            arguments of type xs:float and xs:double, if the argument is positive zero (+0), then
            positive zero (+0) is returned. If the argument is negative zero (-0), then negative
            zero (-0) is returned. If the argument is less than zero (0), but greater than or equal
            to -0.5, then negative zero (-0) is returned. If $arg is of type xs:float or xs:double,
            rounding occurs on the value of the mantissa computed with exponent = 0.</summary>
    </function>
    <function name="seconds-from-dateTime">
        <signature>fn:seconds-from-dateTime($arg as xs:dateTime?) as xs:decimal?</signature>
        <summary>Summary: Returns an xs:decimal value between 0 and 60.999..., both inclusive
            representing the seconds and fractional seconds in the localized value of $arg. Note
            that the value can be greater than 60 seconds to accommodate occasional leap seconds
            used to keep human time synchronized with the rotation of the planet. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="seconds-from-duration">
        <signature>fn:seconds-from-duration($arg as xdt:dayTimeDuration?) as xs:decimal?</signature>
        <summary>Summary: Returns an xs:decimal representing the seconds component in the canonical
            lexical representation of the value of $arg. The result may be negative. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="seconds-from-time">
        <signature>fn:seconds-from-time($arg as xs:time?) as xs:decimal?</signature>
        <summary>Summary: Returns an xs:decimal value between 0 and 60.999..., both inclusive,
            representing the seconds and fractional seconds in the localized value of $arg. Note
            that the value can be greater than 60 seconds to accommodate occasional leap seconds
            used to keep human time synchronized with the rotation of the planet. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="starts-with">
        <signature>fn:starts-with($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean</signature>
        <signature>fn:starts-with( $arg1 as xs:string?, $arg2 as xs:string?, $collation as
            xs:string) as xs:boolean </signature>
        <summary>Summary: Returns an xs:boolean indicating whether or not the value of $arg1 starts
            with a sequence of collation units that provides a minimal match to the collation units
            of $arg2 according to the collation that is used.If the value of $arg1 or $arg2 is the
            empty sequence, it is interpreted as the zero-length string. If the value of $arg2 is
            the zero-length string, then the function returns true. If the value of $arg1 is the
            zero-length string and the value of $arg2 is not the zero-length string, then the
            function returns false.</summary>
    </function>
    <function name="string">
        <signature>fn:string() as xs:string</signature>
        <signature>fn:string($arg as item()?) as xs:string</signature>
        <summary>Summary: Returns the value of $arg represented as a xs:string. If no argument is
            supplied, this function returns the string value of the context item (.).</summary>
    </function>
    <function name="string-join">
        <signature>fn:string-join($arg1 as xs:string*, $arg2 as xs:string) as xs:string</signature>
        <summary>Summary: Returns a xs:string created by concatenating the members of the $arg1
            sequence using $arg2 as a separator. If the value of $arg2 is the zero-length string,
            then the members of $arg1 are concatenated without a separator. If the value of $arg1 is
            the empty sequence, the zero-length string is returned.</summary>
    </function>
    <function name="string-length">
        <signature>fn:string-length() as xs:integer</signature>
        <signature>fn:string-length($arg as xs:string?) as xs:integer</signature>
        <summary>Summary: Returns an xs:integer equal to the length in characters of the value of
            $arg. If the value of $arg is the empty sequence, the xs:integer 0 is returned. If no
            argument is supplied, $arg defaults to the string value (calculated using fn:string())
            of the context item (.). If no argument is supplied and the context item is undefined an
            error is raised: [undefined context item].</summary>
    </function>
    <function name="string-to-codepoints">
        <signature>fn:string-to-codepoints($arg as xs:string?) as xs:integer*</signature>
        <summary>Returns the sequence of code points that constitute an xs:string. If $arg is a
            zero-length string or the empty sequence, the empty sequence is returned.</summary>
    </function>
    <function name="subsequence">
        <signature>fn:subsequence($sourceSeq as item()*, $startingLoc as xs:double) as item()*</signature>
        <signature>fn:subsequence( $sourceSeq as item()*, $startingLoc as xs:double, $length as
            xs:double) as item()* </signature>
        <summary>Summary: Returns the contiguous sequence of items in the value of $sourceSeq
            beginning at the position indicated by the value of $startingLoc and continuing for the
            number of items indicated by the value of $length. If $sourceSeq is the empty sequence,
            the empty sequence is returned. If $startingLoc is zero or negative, the subsequence
            includes items from the beginning of the $sourceSeq. If $length is not specified, the
            subsequence includes items to the end of $sourceSeq. If $length is greater than the
            number of items in the value of $sourceSeq following $startingLoc, the subsequence
            includes items to the end of $sourceSeq. The first item of a sequence is located at
            position 1, not position 0.</summary>
    </function>
    <function name="substring">
        <signature>fn:substring( $sourceString as xs:string?, $startingLoc as xs:double) as
            xs:string </signature>
        <signature>fn:substring( $sourceString as xs:string?, $startingLoc as xs:double, $length as
            xs:double) as xs:string </signature>
        <summary>Summary: Returns the portion of the value of $sourceString beginning at the
            position indicated by the value of $startingLoc and continuing for the number of
            characters indicated by the value of $length. The characters returned do not extend
            beyond $sourceString. If $startingLoc is zero or negative, only those characters in
            positions greater than zero are returned. If the value of $sourceString is the empty
            sequence, the zero-length string is returned.</summary>
    </function>
    <function name="substring-after">
        <signature>fn:substring-after($arg1 as xs:string?, $arg2 as xs:string?) as xs:string</signature>
        <signature>fn:substring-after( $arg1 as xs:string?, $arg2 as xs:string?, $collation as
            xs:string) as xs:string </signature>
        <summary>Summary: Returns the substring of the value of $arg1 that follows in the value of
            $arg1 the first occurrence of a sequence of collation units that provides a minimal
            match to the collation units of $arg2 according to the collation that is used.If the
            value of $arg1 or $arg2 is the empty sequence, it is interpreted as the zero-length
            string. If the value of $arg2 is the zero-length string, then the function returns the
            value of $arg1. If the value of $arg1 does not contain a string that is equal to the
            value of $arg2, then the function returns the zero-length string.</summary>
    </function>
    <function name="substring-before">
        <signature>fn:substring-before($arg1 as xs:string?, $arg2 as xs:string?) as xs:string</signature>
        <signature>fn:substring-before( $arg1 as xs:string?, $arg2 as xs:string?, $collation as
            xs:string) as xs:string </signature>
        <summary>Summary: Returns the substring of the value of $arg1 that precedes in the value of
            $arg1 the first occurrence of a sequence of collation units that provides a minimal
            match to the collation units of $arg2 according to the collation that is used.If the
            value of $arg1 or $arg2 is the empty sequence, it is interpreted as the zero-length
            string. If the value of $arg2 is the zero-length string, then the function returns the
            zero-length string. If the value of $arg1 does not contain a string that is equal to the
            value of $arg2, then the function returns the zero-length string.</summary>
    </function>
    <function name="subtract-dates-yielding-dayTimeDuration">
        <signature>fn:subtract-dates-yielding-dayTimeDuration( $arg1 as xs:date?, $arg2 as xs:date?)
            as xdt:dayTimeDuration? </signature>
        <summary>Summary: Returns the xdt:dayTimeDuration that corresponds to the difference between
            the normalized value of $arg1 and the normalized value of $arg2. The semantics of this
            function are identical to op:subtract-dateTimes-yielding-dayTimeDuration( $arg1 cast as
            xs:dateTime, $arg2 cast as xs:dateTime). If either argument is the empty sequence, the
            empty sequence is returned. If the normalized value of $arg1 precedes in time the
            normalized value of $arg2, then the returned value is a negative duration.</summary>
    </function>
    <function name="subtract-dates-yielding-yearMonthDuration">
        <signature>fn:subtract-dates-yielding-yearMonthDuration( $arg1 as xs:date?, $arg2 as
            xs:date?) as xdt:yearMonthDuration? </signature>
        <summary>Summary: Returns the xdt:yearMonthDuration that corresponds to the difference
            between the normalized value of $arg1 and the normalized value of $arg2. The semantics
            of this function are identical to op:subtract-dateTimes-yielding-yearMonthDuration(
            $arg1 cast as xs:dateTime, $arg2 cast as xs:dateTime). If either argument is the empty
            sequence, the empty sequence is returned. If the normalized value of $arg1 precedes in
            time the normalized value of $arg2, then the returned value is a negative duration.</summary>
    </function>
    <function name="subtract-dateTimes-yielding-dayTimeDuration">
        <signature>fn:subtract-dateTimes-yielding-dayTimeDuration( $arg1 as xs:dateTime?, $arg2 as
            xs:dateTime?) as xdt:dayTimeDuration? </signature>
        <summary>Summary: Returns the xdt:dayTimeDuration that corresponds to the difference between
            the normalized value of $arg1 and the normalized value of $arg2. If either argument is
            the empty sequence, the empty sequence is returned. If the normalized value of $arg1
            precedes in time the normalized value of $arg2, then the returned value is a negative duration.</summary>
    </function>
    <function name="subtract-dateTimes-yielding-yearMonthDuration">
        <signature>fn:subtract-dateTimes-yielding-yearMonthDuration( $arg1 as xs:dateTime?, $arg2 as
            xs:dateTime?) as xdt:yearMonthDuration? </signature>
        <summary>Summary: Returns the xdt:yearMonthDuration that corresponds to the difference
            between the normalized value of $arg1 and the normalized value of $arg2. In general, the
            difference between two xs:dateTime values will be a duration that contains years and
            months as well as days, hours, etc. This function returns the result rounded to contain
            only years and months. The calculation is as follows: first the duration is calculated
            as the value of an xdt:dayTimeDuration in seconds. Then, starting from $arg2 and
            counting towards $arg1, the maximum number of actual whole months in the duration is
            calculated rounding towards zero. If there are a remaining number of days, they are
            discarded. If either argument is the empty sequence, the empty sequence is returned. If
            the normalized value of $arg1 precedes in time the normalized value of $arg2, the
            returned value is a negative duration.</summary>
    </function>
    <function name="subtract-dayTimeDuration-from-date">
        <signature>subtract-dayTimeDuration-from-date( $arg1 as xs:date, $arg2 as
            xdt:dayTimeDuration) as xs:date </signature>
        <summary>Summary: Returns the xs:date computed by negating $arg2 and adding the result to
            the normalized value of $arg1. If $arg2 is negative, then the xs:date returned precedes
            $arg1. The result has the same timezone as arg1. If arg1 has no timezone, the result has
            no timezone.</summary>
    </function>
    <function name="subtract-dayTimeDuration-from-dateTime">
        <signature>op:subtract-dayTimeDuration-from-dateTime( $arg1 as xs:dateTime, $arg2 as
            xdt:dayTimeDuration) as xs:dateTime </signature>
        <summary>Summary: Returns the xs:dateTime computed by negating $arg2 and adding the result
            to the normalized value of $arg1. The result has the same timezone as arg1. If arg1 has
            no timezone, the result has no timezone.</summary>
    </function>
    <function name="subtract-dayTimeDuration-from-time">
        <signature>op:subtract-dayTimeDuration-from-time( $arg1 as xs:time, $arg2 as
            xdt:dayTimeDuration) as xs:time </signature>
        <summary>Summary: The result is calculated by first setting the day component in the
            canonical lexical representation of $arg2 to zero (0) and calculating the value of the
            resulting xdt:dayTimeDuration. Alternatively, the value of $arg2 modulus 86,400 is used.
            This value is subtracted from the normalized value of $arg1 and the result is returned.
            Note that the xs:time returned may occur in a preceding or following day and may be
            greater than $arg1. The result has the same timezone as arg1. If arg1 has no timezone,
            the result has no timezone.</summary>
    </function>
    <function name="subtract-dayTimeDurations">
        <signature>op:subtract-dayTimeDurations( $arg1 as xdt:dayTimeDuration, $arg2 as
            xdt:dayTimeDuration) as xdt:dayTimeDuration </signature>
        <summary>Summary: Returns the result of subtracting the value of $arg2 from the value of
            $arg2. Backs up the "-" operator on xdt:dayTimeDuration values.</summary>
    </function>
    <function name="subtract-times">
        <signature>fn:subtract-times($arg1 as xs:time, $arg2 as xs:time) as xdt:dayTimeDuration</signature>
        <summary>Summary: Returns the xdt:dayTimeDuration that corresponds to the difference between
            the normalized value of $arg1 and the normalized value of $arg2. If the normalized value
            of $arg1 precedes in time the normalized value of $arg2, then the returned value is a
            negative duration.</summary>
    </function>
    <function name="subtract-yearMonthDuration-from-date">
        <signature>op:subtract-yearMonthDuration-from-date( $arg1 as xs:date, $arg2 as
            xdt:yearMonthDuration) as xs:date </signature>
        <summary>Summary: Returns the xs:date computed by negating $arg2 and adding the result to
            the normalized value of $arg1. If $arg2 is negative, then the xs:date returned precedes
            $arg1. The result has the same timezone as arg1. If arg1 has no timezone, the result has
            no timezone.</summary>
    </function>
    <function name="subtract-yearMonthDuration-from-dateTime">
        <signature>op:subtract-yearMonthDuration-from-dateTime( $arg1 as xs:dateTime, $arg2 as
            xdt:yearMonthDuration) as xs:dateTime </signature>
        <summary>Summary: Returns the xs:dateTime computed by negating $arg2 and adding the result
            to the normalized value of $arg1. If $arg2 is negative, then the xs:dateTime returned
            follows $arg1. The result has the same timezone as arg1. If arg1 has no timezone, the
            result has no timezone.</summary>
    </function>
    <function name="subtract-yearMonthDurations">
        <signature>op:subtract-yearMonthDurations( $arg1 as xdt:yearMonthDuration, $arg2 as
            xdt:yearMonthDuration) as xdt:yearMonthDuration </signature>
        <summary>Summary: Returns the result of subtracting the value of $arg2 from the value of
            $arg2. Backs up the "-" operator on xdt:yearMonthDuration values.</summary>
    </function>
    <function name="sum">
        <signature>fn:sum($arg as xdt:anyAtomicType*) as xdt:anyAtomicType</signature>
        <signature>fn:sum( $arg as xdt:anyAtomicType*, $zero as xdt:anyAtomicType?) as
            xdt:anyAtomicType? </signature>
        <summary>Summary: Returns a value obtained by adding together the values in $arg. If the
            single-argument form of the function is used, then the value returned for an empty
            sequence is the xs:integer value 0. If the two-argument form is used, then the value
            returned for an empty sequence is the value of the $zero argument. Any values of type
            xdt:untypedAtomic in $arg are cast to xs:double. The resulting sequence is referred to
            below as the converted sequence. If the converted sequence is empty, then the
            single-argument form of the function returns the xs:integer value 0; the two-argument
            form returns the value of the argument $zero. If the converted sequence contains the
            value NaN, NaN is returned.</summary>
    </function>
    <function name="time-equal">
        <signature>op:time-equal($arg1 as xs:time, $arg2 as xs:time) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is equal to the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="time-greater-than">
        <signature>op:time-greater-than($arg1 as xs:time, $arg2 as xs:time) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is greater than
            the normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="time-less-than">
        <signature>op:time-less-than($arg1 as xs:time, $arg2 as xs:time) as xs:boolean</signature>
        <summary>Summary: Returns true if and only if the normalized value of $arg1 is less than the
            normalized value of $arg2. Returns false otherwise.</summary>
    </function>
    <function name="timezone-from-date">
        <signature>fn:timezone-from-date($arg as xs:date?) as xdt:dayTimeDuration?</signature>
        <summary>Summary: Returns the timezone component of $arg if any. If $arg has a timezone
            component, then the result is an xdt:dayTimeDuration that indicates deviation from UTC;
            its value may range from +14:00 to -14:00 hours, both inclusive. Otherwise, the result
            is the empty sequence. If $arg is the empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="timezone-from-dateTime">
        <signature>fn:timezone-from-dateTime($arg as xs:dateTime?) as xdt:dayTimeDuration?</signature>
        <summary>Summary: Returns the timezone component of $arg if any. If $arg has a timezone
            component, then the result is an xdt:dayTimeDuration that indicates deviation from UTC;
            its value may range from +14:00 to -14:00 hours, both inclusive. Otherwise, the result
            is the empty sequence. If $arg is the empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="timezone-from-time">
        <signature>fn:timezone-from-time($arg as xs:time?) as xdt:dayTimeDuration?</signature>
        <summary>Summary: Returns the timezone component of $arg if any. If $arg has a timezone
            component, then the result is an xdt:dayTimeDuration that indicates deviation from UTC;
            its value may range from +14:00 to -14:00 hours, both inclusive. Otherwise, the result
            is the empty sequence. If $arg is the empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="to">
        <signature>op:to($firstval as xs:integer, $lastval as xs:integer) as xs:integer*</signature>
        <summary>Summary: Returns the sequence containing every xs:integer whose value is between
            the value of $firstval (inclusive) and the value of $lastval (inclusive), in monotonic
            order. If the value of the first operand is greater than the value of the second, the
            empty sequence is returned. If the values of the two operands are equal, a sequence
            containing a single xs:integer equal to the value is returned.</summary>
    </function>
    <function name="tokenize">
        <signature>fn:tokenize($input as xs:string?, $pattern as xs:string) as xs:string+</signature>
        <signature>fn:tokenize( $input as xs:string?, $pattern as xs:string, $flags as xs:string) as
            xs:string+ </signature>
        <summary>Summary: This function breaks the $input string into a sequence of strings,
            treating any substring that matches $pattern as a separator. The separators themselves
            are not returned.</summary>
    </function>
    <function name="trace">
        <signature>fn:trace($value as item()*, $label as xs:string) as item()*</signature>
        <summary>This function is intended to be used in debugging queries by providing a trace of
            their execution.</summary>
    </function>
    <function name="translate">
        <signature>fn:translate( $arg as xs:string?, $mapString as xs:string, $transString as
            xs:string) as xs:string </signature>
        <summary>Summary: Returns the value of $arg modified so that every character in the value of
            $arg that occurs at some position N in the value of $mapString has been replaced by the
            character that occurs at position N in the value of $transString. If the value of $arg
            is the empty sequence, the zero-length string is returned</summary>
    </function>
    <function name="true">
        <signature>fn:true() as xs:boolean</signature>
        <summary>Summary: Returns the xs:boolean value true. Equivalent to xs:boolean("1").</summary>
    </function>
    <function name="union">
        <signature>op:union($parameter1 as node()*, $parameter2 as node()*) as node()*</signature>
        <summary>Summary: Constructs a sequence containing every node that occurs in the values of
            either $parameter1 or $parameter2, eliminating duplicate nodes. Nodes are returned in
            document order. Two nodes are equal if they are op:is-same-node().</summary>
    </function>
    <function name="unordered">
        <signature>fn:unordered($sourceSeq as item()*) as item()*</signature>
        <summary>Summary: This function takes a sequence, or more typically, an expression, that
            evaluates to a sequence, as input and returns an arbitrary ·implementation dependent·
            permutation of the input sequence. Query optimizers may be able to do a better job if
            the order of the output sequence is not specified. For example, if you want to retrieve
            all the prices from a purchase order, and if there is an index on prices, it may be
            possible to compute an unordered result more efficiently.</summary>
    </function>
    <function name="upper-case">
        <signature>fn:upper-case($arg as xs:string?) as xs:string</signature>
        <summary>Summary: Returns the value of $srcval after translating every character to its
            upper-case correspondent. Every character that does not have an upper-case correspondent
            is included in the returned value in its original form. If the value of $arg is the
            empty sequence, the zero-length string is returned.</summary>
    </function>
    <function name="year-from-date">
        <signature>fn:year-from-date($arg as xs:date?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer representing the year in the localized value of
            $arg. The value may be negative. If $arg is the empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="year-from-dateTime">
        <signature>fn:year-from-dateTime($arg as xs:dateTime?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer representing the year component in the localized
            value of $arg. The result may be negative. If $arg is the empty sequence, returns the
            empty sequence.</summary>
    </function>
    <function name="yearMonthDuration-equal">
        <signature>op:yearMonthDuration-equal( $arg1 as xdt:yearMonthDuration, $arg2 as
            xdt:yearMonthDuration) as xs:boolean </signature>
        <summary>Summary: Returns true if and only if $arg1 is equal to $arg2. Returns false otherwise.</summary>
    </function>
    <function name="yearMonthDuration-greater-than">
        <signature>op:yearMonthDuration-greater-than( $arg1 as xdt:yearMonthDuration, $arg2 as
            xdt:yearMonthDuration) as xs:boolean </signature>
        <summary>Summary: Returns true if and only if $arg1 is greater than $arg2. Returns false otherwise.</summary>
    </function>
    <function name="yearMonthDuration-less-than">
        <signature>op:yearMonthDuration-less-than( $arg1 as xdt:yearMonthDuration, $arg2 as
            xdt:yearMonthDuration) as xs:boolean </signature>
        <summary>Summary: Returns true if and only if $arg1 is less than $arg2. Returns false otherwise.</summary>
    </function>
    <function name="years-from-duration">
        <signature>fn:years-from-duration($arg as xdt:yearMonthDuration?) as xs:integer?</signature>
        <summary>Summary: Returns an xs:integer representing the years component in the canonical
            lexical representation of the value of $arg. The result may be negative. If $arg is the
            empty sequence, returns the empty sequence.</summary>
    </function>
    <function name="zero-or-one">
        <signature>fn:zero-or-one($arg as item()*) as item()?</signature>
        <summary>Summary: Returns $arg if it contains zero or one items. Otherwise, raises an error
            [fn:zero-or-one called with a sequence containing more than one item]. The type of the
            result depends on the type of $arg.</summary>
    </function>
</xquery_functions>