import { AstType, EastFunction, NewArrayFunction, RangeFunction, SortFunction, ToArrayFunction, Variable } from '../functions';
import { ArrayType, BooleanType, DictType, EastType, IntegerType, SetType, SubType, ValueTypeOf } from '../types';
import { Expression } from './core';
/**
 * Construct an new array with the given values.
 *
 * @param value_type the {@link EastType} the values of the array will be
 * @param values a list of {@link Expression}s to insert as values into the new array (optional)
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // create a new empty array that can contain strings
 * NewArray(StringType)
 * // create a new array containing ["a", "b"]
 * NewArray(StringType, [Const("a"), Const("b")])
 * ```
 */
export declare function NewArray<T extends EastType>(value_type: T, values?: (ValueTypeOf<NoInfer<T>> | {
    type: SubType<NoInfer<T>>;
    ast_type: AstType;
})[]): NewArrayFunction<ArrayType<T>>;
/**
 * Construct an array with a contiguous range of integers, `[start, start+1n, ..., stop-1n, stop]`.
 *
 * The range always includes both `start` and `stop`, unless `start` is greater than `stop`
 * in which case the output is an empty array.
 *
 * @param start an {@link Expression} for the first integer.
 * @param stop an {@link Expression} for the first integer.
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Range(1, Variable("n", IntegerType))
 * ```
 */
export declare function Range(start: Expression<IntegerType>, stop: Expression<IntegerType>): RangeFunction<ArrayType<IntegerType>>;
/**
 * Return an array where each output `value` is calculated from each element of the input `collection`.
 *
 * @param collection the {@link Expression} for the input set
 * @param value a function from input key to an {@link Expression} to calculate the output value
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // convert a set to an array
 * ToArray(set)
 * // create an array by applying the UpperCase function to each element of the set
 * ToArray(set, x => UpperCase(x))
 * ```
 */
export declare function ToArray<T extends SetType, U extends EastType>(collection: EastFunction<T>, value: ((key: Variable<T["value"]>) => EastFunction<U>) | (() => EastFunction<U>)): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends SetType>(collection: EastFunction<T>): ToArrayFunction<ArrayType<T["value"]>>;
/**
 * Return an array where each output `value` is calculated from each element of the input `collection`.
 *
 * @param collection the {@link Expression} for the input dictionary
 * @param value a function from input value and key to an {@link Expression} to calculate the output value
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // create an array from the values of a dictionary
 * ToArray(dict)
 * // create an array by applying the UpperCase function to keys of a dictionary
 * ToArray(dict, (value, key) => UpperCase(key))
 * ```
 */
export declare function ToArray<T extends DictType, U extends EastType>(collection: EastFunction<T>, value: (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction<U>): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends DictType, U extends EastType>(collection: EastFunction<T>, value: (value: Variable<T["value"]["value"]>) => EastFunction<U>): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends DictType, U extends EastType>(collection: EastFunction<T>, value: () => EastFunction<U>): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends DictType>(collection: EastFunction<T>): ToArrayFunction<ArrayType<T["value"]["value"]>>;
/**
 * Return an array where each output `value` is calculated from each element of the input `collection`.
 *
 * @param collection the {@link Expression} for the input array
 * @param value a function from input value and key to an {@link Expression} to calculate the output value
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // create a new array by applying the UpperCase function to each element of the input
 * ToArray(array, x => UpperCase(x))
 * ```
 */
export declare function ToArray<T extends ArrayType, U extends EastType>(collection: EastFunction<T>, value: (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction<U>): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends ArrayType, U extends EastType>(collection: EastFunction<T>, value: (value: Variable<T["value"]>) => EastFunction<U>): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends ArrayType, U extends EastType>(collection: EastFunction<T>, value: () => EastFunction<U>): ToArrayFunction<ArrayType<U>>;
export declare function ToArray<T extends ArrayType>(collection: EastFunction<T>): ToArrayFunction<ArrayType<T["value"]>>;
/**
 * Sort an array in place, according an ordering defined by the comparison function `isless`.
 * Primitive types will be sorted automatically according to `Less`.
 *
 * @param collection the {@link Expression} for the input array
 * @param isless a function from the `first` and `second` value to an {@link Expression} to calculate whether `first` is smaller than `second` (defaults to `Less`)
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // ...
 * // Sort an array of datetimes into ascending order
 * AscendingDates: Sort(array_of_dates)
 * // Sort an array of datetimes into descending order
 * DescendingDates: Sort(array_of_dates, Greater)
 * // ...
 * ```
 */
export declare function Sort<T extends ArrayType, IsLess extends (first: Variable<T["value"]>, second: Variable<T["value"]>) => EastFunction<BooleanType>>(collection: EastFunction<T>, isless?: IsLess): SortFunction<T>;