import { InterpreterSpec, InterpreterSpecSingle } from '../types';
export declare const $$INDEX: string[];
export declare const $$ARRAY: string[];
export declare const $$ACC: string[];
export declare const $$SORT_A: string[];
export declare const $$SORT_B: string[];
/**
 * Equivalent of `Array.prototype.includes`.
 *
 * @function $arrayIncludes
 * @param {*} searchValue
 * @param {Array} [array=$$VALUE]
 * @returns {Boolean} includes
 */
export declare const $arrayIncludes: InterpreterSpec;
/**
 * Similar to `$arrayIncludes`, but receives an array
 * of values to be searched for and returns whether the
 * context array contains all of the searched values.
 *
 * @function $arrayIncludesAll
 * @param {Array} searchValues
 * @param {Array} [array=$$VALUE]
 * @returns {Boolean} includesAll
 */
export declare const $arrayIncludesAll: InterpreterSpec;
/**
 * Similar to `$arrayIncludes`, but returns true if
 * any of the searched values is in the array.
 *
 * @function $arrayIncludesAny
 * @param {Array} searchValue
 * @param {Array} [array=$$VALUE]
 * @returns {Boolean} includesAny
 */
export declare const $arrayIncludesAny: InterpreterSpec;
/**
 * @function $arrayLength
 * @param {Array} [array=$$VALUE]
 * @returns {Number} length
 */
export declare const $arrayLength: InterpreterSpec;
/**
 * @function $arrayReduce
 * @param {Expression} reduceExp An expression that returns the
 *                               result of reduction. Has access to:
 *                               `$$PARENT_SCOPE`, `$$VALUE`, `$$INDEX`,
 *                               `$$ARRAY`, `$$ACC`
 * @param {*} start
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayReduce: InterpreterSpec;
/**
 * @function $arrayMap
 * @param {Expression} mapExp Expression to be evaluated for each
 *                            item and which return value will be
 *                            available in the resulting array. Has
 *                            access to: `$$PARENT_SCOPE`, `$$VALUE`,
 *                            `$$INDEX`, `$$ARRAY`, `$$ACC`
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayMap: InterpreterSpec;
/**
 * `Array.prototype.every`
 *
 * Result is similar to logical operator `$and`. Main difference
 * (and reason for existence as isolate expression) is that
 * $arrayEvery exposes array iteration variables:
 * `$$PARENT_SCOPE`, `$$VALUE`, `$$INDEX`, `$$ARRAY`
 *
 * @function $arrayEvery
 * @param {Expression} testExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayEvery: InterpreterSpec;
/**
 * `Array.prototype.some`
 *
 * @function $arraySome
 * @param {Expression} someExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arraySome: InterpreterSpec;
export declare const $arrayFilterAsyncParallel: InterpreterSpecSingle;
export declare const $arrayFilterAsyncSerial: InterpreterSpecSingle;
/**
 * @function $arrayFilter
 * @param {Boolean} queryExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayFilter: InterpreterSpec;
/**
 * @function $arrayFindIndex
 * @param {Boolean} queryExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayFindIndex: InterpreterSpec;
/**
 * @function $arrayIndexOf
 * @param {*} value
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayIndexOf: InterpreterSpec;
/**
 * @function $arrayFind
 * @param {Boolean} queryExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayFind: InterpreterSpec;
/**
 * @function $arrayReverse
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayReverse: InterpreterSpec;
/**
 * @function $arraySort
 * @param {String | Expression | [Expression, string]} sort
 * @param {Array} [array=$$VALUE]
 */
export declare const $arraySort: InterpreterSpec;
/**
 * @function $arrayPush
 * @param {*} valueExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayPush: InterpreterSpec;
/**
 * @function $arrayPop
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayPop: InterpreterSpec;
/**
 * @function $arrayUnshift
 * @param {*} valueExp
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayUnshift: InterpreterSpec;
/**
 * @function $arrayShift
 * @param {Array} [array=$$VALUE]
 */
export declare const $arrayShift: InterpreterSpec;
/**
 * @function $arraySlice
 * @param {Number} start
 * @param {Number} end
 * @param {Array} [array=$$VALUE]
 * @returns {Array}
 */
export declare const $arraySlice: InterpreterSpec;
/**
 * @function $arrayReplace
 * @param {Number | [Number, Number]} indexOrRange
 * @param {Array} values
 * @param {Array} [array=$$VALUE]
 * @returns {Array}
 */
export declare const $arrayReplace: InterpreterSpec;
/**
 * Adds items at the given position.
 *
 * @function $arrayAddAt
 * @param {Number} index
 * @param {* | Array} values
 * @param {Array} [array=$$VALUE]
 * @returns {Array} resultingArray The array with items added at position
 */
export declare const $arrayAddAt: InterpreterSpec;
/**
 * @function $arrayRemoveAt
 * @param {Number} index
 * @param {Number} [countExp=1]
 * @param {Array} [array=$$VALUE]
 * @returns {Array} resultingArray The array without the removed item
 */
export declare const $arrayRemoveAt: InterpreterSpec;
/**
 * @function $arrayJoin
 * @param {String} separator
 * @param {Array} [array=$$VALUE]
 * @returns {String}
 */
export declare const $arrayJoin: InterpreterSpec;
/**
 * @function $arrayAt
 * @param {Number} index
 * @param {Array} [array=$$VALUE]
 * @returns {*} value
 */
export declare const $arrayAt: InterpreterSpec;
export declare const ARRAY_EXPRESSIONS: {
    $arrayIncludes: InterpreterSpecSingle;
    $arrayIncludesAll: InterpreterSpecSingle;
    $arrayIncludesAny: InterpreterSpecSingle;
    $arrayLength: InterpreterSpecSingle;
    $arrayReduce: InterpreterSpecSingle;
    $arrayMap: {
        sync: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
        async: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
    };
    $arrayEvery: {
        sync: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
        async: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
    };
    $arraySome: {
        sync: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
        async: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
    };
    $arrayFilter: {
        sync: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
        async: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
    };
    $arrayFindIndex: {
        sync: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
        async: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
    };
    $arrayIndexOf: InterpreterSpecSingle;
    $arrayFind: {
        sync: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
        async: InterpreterSpecSingle | import("../types").InterpreterFunction | null;
    };
    $arrayReverse: InterpreterSpecSingle;
    $arraySort: InterpreterSpecSingle;
    $arrayPush: InterpreterSpecSingle;
    $arrayPop: InterpreterSpecSingle;
    $arrayUnshift: InterpreterSpecSingle;
    $arrayShift: InterpreterSpecSingle;
    $arraySlice: InterpreterSpecSingle;
    $arrayReplace: InterpreterSpecSingle;
    $arrayAddAt: InterpreterSpecSingle;
    $arrayRemoveAt: InterpreterSpecSingle;
    $arrayJoin: InterpreterSpecSingle;
    $arrayAt: InterpreterSpecSingle;
};