import { DeleteFunction, EastFunction, FilterFunction, FilterMapFunction, GetFunction, InFunction, InsertFunction, MapValuesFunction, ReduceFunction, SizeFunction, UpdateFunction, Variable } from '../functions';
import { ArrayType, BlobType, BooleanType, DictType, EastType, EastTypeOf, IntegerType, NullType, PrimitiveValue, SetType, StringType, Value, ValueTypeOf, VariantType } from '../types';
import { Expression } from './core';
/**
 * Return `true` if `key` is in `set`, or `false` otherwise.
 *
 * @param set the {@link Expression} for the set
 * @param key the {@link Expression} for the value to search for
 *
 * @category Expression
 *
 * @example
 * ```typescript
 *  // ...
 *  // Determine if the product is in the set of currently available products
 *  ProductIsAvailable: In(
 *      Variable("AvailableProductIds", SetType<StringType>),
 *      Variable("ProductId", StringType),
 *  ),
 *  // ...
 * ```
 */
export declare function In<T extends ArrayType>(collection: EastFunction<T>, key: bigint): InFunction<BooleanType>;
export declare function In<T extends ArrayType>(collection: EastFunction<T>, key: EastFunction<IntegerType>): InFunction<BooleanType>;
export declare function In<T extends DictType, U extends ValueTypeOf<T["value"]["key"]>>(collection: EastFunction<T>, key: U): InFunction<BooleanType>;
export declare function In<T extends DictType, U extends T["value"]["key"]>(collection: EastFunction<T>, key: EastFunction<U>): InFunction<BooleanType>;
export declare function In<T extends SetType, U extends ValueTypeOf<T["value"]>>(setcollection: EastFunction<T>, key: U): InFunction<BooleanType>;
export declare function In<T extends SetType, U extends T["value"]>(collection: EastFunction<T>, key: EastFunction<U>): InFunction<BooleanType>;
/**
 * Return a dictionary where `key` has been inserted with `value` into `collection`,
 * overwriting an existing value if it exists.
 *
 * Note: the input `collection` is unmodified (you need to use the return value)
 *
 * @param collection the {@link Expression} for the dictionary
 * @param key the {@link Expression} for the key to insert
 * @param value the {@link Expression} for the value to insert
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Insert(dict, key, value)
 * ```
 */
export declare function Insert<V extends EastType, T extends DictType<StringType, NoInfer<V>>>(collection: EastFunction<T>, key: Expression<T["value"]["key"]>, value: EastFunction<V>): InsertFunction<T>;
export declare function Insert<T extends DictType>(collection: EastFunction<T>, key: Expression<T["value"]["key"]>, value: ValueTypeOf<T["value"]["value"]>): InsertFunction<T>;
/**
 * Return a set where `key` has been inserted into `collection`.
 *
 * Note: the input `collection` is unmodified (you need to use the return value)
 *
 * @param collection the {@link Expression} for the set
 * @param key the {@link Expression} for the key to insert
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Insert(set, key)
 * ```
 */
export declare function Insert<T extends SetType>(collection: EastFunction<T>, key: Expression<T["value"]>): InsertFunction<T>;
/**
 * Return an array where `value` has been inserted to the start or end of `collection`.
 *
 * Note: the input `collection` is unmodified (you need to use the return value)
 *
 * @param collection the {@link Expression} for the array
 * @param key must be `"first"` or `"last"`
 * @param value the {@link Expression} for the value to insert
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Insert(array, "last", value)
 * ```
 */
export declare function Insert<V extends EastType, T extends ArrayType<NoInfer<V>>>(collection: EastFunction<T>, key: "first" | "last", value: EastFunction<V>): InsertFunction<T>;
export declare function Insert<T extends ArrayType>(collection: EastFunction<T>, key: "first" | "last", value: ValueTypeOf<NoInfer<T>["value"]>): InsertFunction<T>;
/**
 * Return an array where `key` has been updated with `value` into `collection`,
 * overwriting the existing value.
 *
 * Note: the input `collection` is unmodified (you need to use the return value).
 *
 * @param collection the {@link Expression} for the array
 * @param key the {@link Expression} for the key (i.e. index) to update
 * @param value the {@link Expression} for the value to update
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Update(array, index, value)
 * ```
 */
export declare function Update<V extends EastType, T extends ArrayType<NoInfer<V>>>(collection: EastFunction<T>, key: bigint | EastFunction<IntegerType>, value: EastFunction<V>): UpdateFunction<T>;
export declare function Update<T extends ArrayType>(collection: EastFunction<T>, key: bigint | EastFunction<IntegerType>, value: ValueTypeOf<NoInfer<T>["value"]>): UpdateFunction<T>;
/**
 * Return an dictionary where `key` has been updated with `value` into `collection`,
 * overwriting the existing value.
 *
 * Note: the input `collection` is unmodified (you need to use the return value).
 *
 * @param collection the {@link Expression} for the dictionary
 * @param key the {@link Expression} for the key to update
 * @param value the {@link Expression} for the value to update
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Update(dict, key, value)
 * ```
 */
export declare function Update<V extends EastType, T extends DictType<StringType, NoInfer<V>>>(collection: EastFunction<T>, key: string | EastFunction<StringType>, value: EastFunction<V>): UpdateFunction<T>;
export declare function Update<T extends DictType>(collection: EastFunction<T>, key: string | EastFunction<StringType>, value: ValueTypeOf<NoInfer<T>["value"]["value"]>): UpdateFunction<T>;
/**
 * Return a dictionary with a given `key` deleted from `collection`.
 *
 * Note: the input `collection` is unmodified (you need to use the return value)
 *
 * @param collection the {@link Expression} for the dictionary
 * @param key the {@link Expression} for the key to delete
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Delete(dict, key)
 * ```
 */
export declare function Delete<T extends DictType>(collection: EastFunction<T>, key: Expression<T["value"]["key"]>): DeleteFunction<T>;
/**
 * Return a set with a given `key` deleted from `collection`.
 *
 * @param collection the {@link Expression} for the set
 * @param key the {@link Expression} for the key to delete
 *
 * Note: currently this mutates `collection`, which can have unintended consequences if it is used elsewhere.
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Delete(set, key)
 * ```
 */
export declare function Delete<T extends SetType>(collection: EastFunction<T>, key: Expression<T["value"]>): DeleteFunction<T>;
/**
 * Return an array with the last element deleted.
 *
 * @param collection the {@link Expression} for the array
 *
 * Note: currently this mutates `collection`, which can have unintended consequences if it is used elsewhere.
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * Delete(array, "last")
 * ```
 */
export declare function Delete<T extends ArrayType>(collection: EastFunction<T>, key: "first" | "last"): DeleteFunction<T>;
/**
 * Get a value from `collection` corresponding to the given `key`. If `key` is not found, returns `default`.
 *
 * @param collection the {@link Expression} for the dictionary
 * @param key the {@link Expression} for the (string) key
 * @param default the {@link Expression} for the value to return if the key is not found (optional, if not provided results in runtime error)
 *
 * @category Expression
 * @example
 * ```typescript
 *  // ...
 *  // Get the name of a product from a dictionary from id -> name
 *  ProductName: Get(
 *      Variable("ProductNames", DictType(StringType)),
 *      Variable("ProductId", StringType),
 *      null
 *  ),
 *  // ...
 *  ```
 */
export declare function Get<T extends DictType, D extends EastFunction>(collection: EastFunction<T>, key: EastFunction<T["value"]["key"]>, defaultValue: D & ((D["type"] & T["value"]["value"]) extends never ? never : unknown)): GetFunction<D["type"] & T["value"]["value"]>;
export declare function Get<T extends DictType, D extends PrimitiveValue>(collection: EastFunction<T>, key: EastFunction<T["value"]["key"]>, defaultValue: D & ((EastTypeOf<D> & T["value"]["value"]) extends never ? never : unknown)): GetFunction<EastTypeOf<D> & T["value"]["value"]>;
export declare function Get<T extends DictType>(collection: EastFunction<T>, key: EastFunction<T["value"]["key"]>): GetFunction<T["value"]["value"]>;
/**
 * Get a value from `collection` corresponding to the given `key`. If `key` is not found,
 * returns `default`. (Note: the first key of an array is zero).
 *
 * @param collection the {@link Expression} for the array
 * @param key the {@link Expression} for the (integer) key
 * @param default the {@link Expression} for the value to return if the key is not found (optional, if not provided results in runtime error)
 *
 * @category Expression
 *
 * @example
 * ```typescript
 *  // ...
 *  // Get the first item in a list of items
 *  FirstItem: Get(
 *      Variable("Items", ArrayType(StringType)),
 *      0n
 *  ),
 *  // ...
 * ```
 */
export declare function Get<T extends ArrayType, D extends EastFunction>(collection: EastFunction<T>, key: EastFunction<IntegerType>, defaultValue: D & ((D["type"] & T["value"]) extends never ? never : unknown)): GetFunction<D["type"] & T["value"]>;
export declare function Get<T extends ArrayType, D extends PrimitiveValue>(collection: EastFunction<T>, key: EastFunction<IntegerType>, defaultValue: D & ((EastTypeOf<D> & T["value"]) extends never ? never : unknown)): GetFunction<EastTypeOf<D> & T["value"]>;
export declare function Get<T extends ArrayType>(collection: EastFunction<T>, key: EastFunction<IntegerType>): GetFunction<T["value"]>;
/**
 * Get the number of elements in a collection.
 *
 * @param collection the {@link Expression} for the array, dictionary or set
 *
 * @category Expression
 *
 * @example
 * ```typescript
 *  // ...
 *  // Get the number of employees on a shift
 *  NumberOfShiftEmployees: Size(
 *      Variable("ShiftEmployeeIds", SetType<StringType>),
 *  ),
 *  // ...
 * ```
 */
export declare function Size<T extends SetType | DictType | ArrayType | BlobType | StringType>(collection: EastFunction<T>): SizeFunction<IntegerType>;
/**
 * Return a set containing only values where the `predicate` was `true`.
 *
 * @param collection the {@link Expression} for the input set
 * @param predicate a function from the input key to an {@link Expression} to calculate whether to keep the element
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // ...
 * // Get only the non-null elements of a set
 * SubscriptionProducts: Filter(
 *     Variable("ProductIds", SetType(StringType)),
 *     productId => Get(
 *         Variable("ProductIsSubscription", BooleanType),
 *         productId
 *     )
 * ),
 * // ...
 * ```
 */
export declare function Filter<T extends SetType, Pred extends (key: Variable<T["value"]>) => EastFunction<BooleanType>>(collection: EastFunction<T>, predicate: Pred): FilterFunction<T>;
/**
 * Return a dictionary containing only values where the `predicate` was `true`.
 *
 * @param collection the {@link Expression} for the input dictionary
 * @param predicate a function from the input value and key to an {@link Expression} to calculate whether to keep the element
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // ...
 * // Get only the non-null elements of a dictionary
 * FilteredDict: Filter(
 *     Variable("Dict", DictType(StringType, Nullable(StringType))),
 *     value => NotEqual(value, null)
 * ),
 * // ...
 * ```
 */
export declare function Filter<T extends DictType, Pred extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction<BooleanType>>(collection: EastFunction<T>, predicate: Pred): FilterFunction<T>;
/**
 * Return an array containing only values where the `predicate` was `true`.
 *
 * @param collection the {@link Expression} for the input array
 * @param predicate a function from the input value and key to an {@link Expression} to calculate whether to keep the element
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // ...
 * // Get only the non-null elements of an array
 * FilteredArray: Filter(
 *     Variable("Array", ArrayType(Nullable(StringType))),
 *     value => NotEqual(value, null)
 * )
 * // ...
 * ```
 */
export declare function Filter<T extends ArrayType, Pred extends (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction<BooleanType>>(collection: EastFunction<T>, predicate: Pred): FilterFunction<T>;
/**
 * Return a dictionary mapping the keys of a set through a function. The output keys match
 * the input set.
 *
 * @param collection the {@link Expression} for the input set
 * @param value a function from the input key to an {@link Expression} to calculate the output value
 *
 * @deprecated use ToDict instead
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // ...
 * // Create full names for each of a set of employees
 * SomeEmployeeNames: MapDict(
 *     Variable("SomeEmployeeIds", SetType<StringType>),
 *     employeeId => StringJoin`${Get(Variable("EmployeeFirstNames", DictType(StringType)), employeeId)} ${Get(Variable("EmployeeLastNames", DictType(StringType)), employeeId)}`,
 * ),
 * // ...
 * ```
 */
export declare function MapDict<T extends SetType, U extends (key: Variable<T["value"]>) => EastFunction>(collection: EastFunction<T>, value: U): MapValuesFunction<DictType<T["value"], ReturnType<U>["type"]>>;
/**
 * Return a dictionary mapping the values of a dictionary through a function. The output
 * keys match the keys of the input dictionary.
 *
 * @param collection the {@link Expression} for the input dictionary
 * @param value a function from the input value and key to an {@link Expression} to calculate the output value
 *
 * @deprecated use ToDict instead
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // ...
 * // Calculate the total price from collections of product unit price and quantity
 * ProductTotalPrices: MapDict(
 *     Variable("ProductQuantities", DictType(StringType, IntegerType)),
 *     (quantity, productId) => Multiply(
 *         quantity,
 *         Get(
 *             Variable("ProductUnitPrices", DictType(StringType, IntegerType)),
 *             productId
 *         )
 *     )
 * )
 * // ...
 * ```
 */
export declare function MapDict<T extends DictType, U extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction>(collection: EastFunction<T>, value: U): MapValuesFunction<DictType<T["value"]["key"], ReturnType<U>["type"]>>;
/**
 * Return an array mapping and filtering the entries of an array via a function returning an Option variant.
 * The data in the "some" case is kept, while the "none" case is discarded (filtered out).
 * The ordering of entries is preserved.
 *
 * @param collection the {@link Expression} for the input array
 * @param value a function from the input key to an {@link Expression} to calculate the output value as an option variant
 *
 * @category Expression
 */
export declare function FilterMap<T extends ArrayType, U extends (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction<VariantType<{
    none: NullType;
    some: EastType;
}>>>(collection: EastFunction<T>, value: U): FilterMapFunction<ArrayType<ReturnType<U>["type"]["value"]["some"]>>;
/**
 * Return a set mapping and filtering the entries of a set via a function returning an Option variant.
 * The data in the "some" case is kept, while the "none" case is discarded (filtered out).
 *
 * @param collection the {@link Expression} for the input set
 * @param value a function from the input key to an {@link Expression} to calculate the output value as an option variant
 *
 * @category Expression
 */
export declare function FilterMap<T extends SetType, U extends (key: Variable<T["value"]>) => EastFunction<VariantType<{
    none: NullType;
    some: StringType;
}>>>(collection: EastFunction<T>, value: U): FilterMapFunction<SetType<ReturnType<U>["type"]["value"]["some"]>>;
/**
 * Return a dictionary mapping and filtering the entries of a dictionary via a function returning an Option variant.
 * The data in the "some" case is kept, while the "none" case is discarded (filtered out).
 * The output keys match the keys of the input dictionary.
 *
 * @param collection the {@link Expression} for the input dictionary
 * @param value a function from the input value and key to an {@link Expression} to calculate the output value as an option variant
 * @category Expression
 * @see `mapFilter`
 *
 */
export declare function FilterMap<T extends DictType, U extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction<VariantType<{
    none: NullType;
    some: EastType;
}>>>(collection: EastFunction<T>, value: U): FilterMapFunction<DictType<T["value"]["key"], ReturnType<U>["type"]["value"]["some"]>>;
/**
 * Loop over the values in an array in order, performing a reduction.
 *
 * Each reduction starts with an `initial` value. For every element of the collection, the
 * `reducer` calculates a new value based on both the data and the result of the `previous`
 * iteration. The `previous` variable acts to transfer state from one iteration to the next.
 *
 * Reductions can be quite powerful - while many are simple (e.g. summing an array), it
 * is possible to construct rich data structures incrementally through a reduction.
 *
 * @param collection - the {@link Expression} for the input collection to be reduced over
 * @param reducer - a function of the `previous` value and input `value` and `key` variables returning an {@link Expression} giving the next value of the reduction * @param initial - an {@link Expression} for the initial value of the reduction
 * @param previous - a {@link Variable} holding the current state of the reduction
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // To add up all the values in an array of integers
 * Reduce(
 *     array,
 *     (previous, value) => Add(previous, value),
 *     Const(0n)
 * )
 * ```
 */
export declare function Reduce<T extends ArrayType, I extends EastFunction, R extends (previous: Variable<I["type"]>, value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction>(collection: EastFunction<T>, reducer: R & ((ReturnType<R>["type"] & I["type"]) extends never ? never : unknown), initial: I): ReduceFunction<ReturnType<R>["type"] & I["type"]>;
export declare function Reduce<T extends ArrayType, I extends Value, R extends (previous: Variable<EastTypeOf<I>>, value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction>(collection: EastFunction<T>, reducer: R & ((ReturnType<R>["type"] & EastTypeOf<I>) extends never ? never : unknown), initial: I): ReduceFunction<ReturnType<R>["type"] & EastTypeOf<I>>;
/**
 * Loop over the values in an array in order, performing a reduction.
 *
 * Each reduction starts with an `initial` value. For every element of the collection, the
 * `reducer` calculates a new value based on both the data and the result of the `previous`
 * iteration. The `previous` variable acts to transfer state from one iteration to the next.
 *
 * Reductions can be quite powerful - while many are simple (e.g. summing an array), it
 * is possible to construct rich data structures incrementally through a reduction.
 *
 * @param collection - the {@link Expression} for the input collection to be reduced over
 * @param reducer - a function of the `previous` value and input `key` variables returning an {@link Expression} giving the next value of the reduction
 * @param initial - an {@link Expression} for the initial value of the reduction
 * @returns The final output of `reducer`, or else `initial` for empty collections
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // Given a `set` of `key`s, calculate the sum of the corresponding values in
 * // an integer dictionary `dict`
 * Reduce(
 *     set,
 *     (previous, key) => Add(previous, Get(dict, key),
 *     Const(0n)
 * )
 * ```
 */
export declare function Reduce<T extends SetType, I extends EastFunction, R extends (previous: Variable<I["type"]>, key: Variable<T["value"]>) => EastFunction>(collection: EastFunction<T>, reducer: R & ((ReturnType<R>["type"] & I["type"]) extends never ? never : unknown), initial: I): ReduceFunction<ReturnType<R>["type"] & I["type"]>;
export declare function Reduce<T extends SetType, I extends Value, R extends (previous: Variable<EastTypeOf<I>>, key: Variable<T["value"]>) => EastFunction>(collection: EastFunction<T>, reducer: R & ((ReturnType<R>["type"] & EastTypeOf<I>) extends never ? never : unknown), initial: I): ReduceFunction<ReturnType<R>["type"] & EastTypeOf<I>>;
/**
 * Loop over the values in an array in order, performing a reduction.
 *
 * Each reduction starts with an `initial` value. For every element of the collection, the
 * `reducer` calculates a new value based on both the data and the result of the `previous`
 * iteration. The `previous` variable acts to transfer state from one iteration to the next.
 *
 * Reductions can be quite powerful - while many are simple (e.g. summing an array), it
 * is possible to construct rich data structures incrementally through a reduction.
 *
 * @param collection - the {@link Expression} for the input collection to be reduced over
 * @param reducer - a function of the `previous` value and input `value` and `key` variables returning an {@link Expression} giving the next value of the reduction
 * @param initial - an {@link Expression} for the initial value of the reduction
 * @returns The final output of `reducer`, or else `initial` for empty collections
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // To add up all the values in a dictionary of integers
 * Reduce(
 *
 *     dict,
 *     (previous, value) => Add(previous, value),
 *     Const(0n)
 * )
 * ```
 */
export declare function Reduce<T extends DictType, I extends EastFunction, R extends (previous: Variable<I["type"]>, value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction>(collection: EastFunction<T>, reducer: R & ((ReturnType<R>["type"] & I["type"]) extends never ? never : unknown), initial: I): ReduceFunction<ReturnType<R>["type"] & I["type"]>;
export declare function Reduce<T extends DictType, I extends Value, R extends (previous: Variable<EastTypeOf<I>>, value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction>(collection: EastFunction<T>, reducer: R & ((ReturnType<R>["type"] & EastTypeOf<I>) extends never ? never : unknown), initial: I): ReduceFunction<ReturnType<R>["type"] & EastTypeOf<I>>;