import { AstType, EastFunction, KeysFunction, NewDictFunction, OnlyKeyFunction, ToDictFunction, Variable } from '../functions';
import { ArrayType, DictType, EastType, EastTypeOf, IntegerType, Nullable, SetType, StringType, SubType, Value, ValueTypeOf } from '../types';
import { Expression } from './core';
/**
 * Construct an new dictionary with the given `keys` and `values`.
 *
 * @param key_type the {@link EastType} the keys of the dictionary will be
 * @param value_type the {@link EastType} the values of the dictionary will be
 * @param keys an array of {@link Expression}s to insert as keys into the new dictionary (optional)
 * @param values an array of {@link Expression}s to insert as values into the new dictionary (must be the same length as `keys`) (optional)
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // create a new empty dictionary with string keys and integer values
 * NewDict(StringType, IntegerType)
 * // create a new dictionary containing entries ["a", 1n] and ["b", 2n]
 * NewDict(StringType, IntegerType, [Const("a"), Const("b")], [Const(1n), Const(2n)])
 * ```
 */
export declare function NewDict<K extends StringType, T extends EastType>(key_type: K, value_type: T, keys?: Expression<K>[], values?: (ValueTypeOf<NoInfer<T>> | {
    type: SubType<NoInfer<T>>;
    ast_type: AstType;
})[]): NewDictFunction<DictType<K, T>>;
/**
 * Return a dictionary where each output `key` and `value` is calculated from elements of the input `collection`.
 * If the `key` is `null` the element is ignored. In case of duplicate keys, the last value is kept, unless initial_value
 * is provided in which case the previous value can be used to calculate the new value.
 *
 * @param collection the {@link Expression} for the input set
 * @param value a function from the input key (and previous value) to an {@link Expression} to calculate the output value
 * @param key a function from the input key to an {@link Expression} to calculate the output key
 * @param initial_value an expression for an initial value given to each key and passed into `value`
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // create a new dictionary mapping the keys of a set to their uppercase values
 * ToDict(
 *   set,
 *   x => UpperCase(x),
 *   x => x,
 * )
 * ```
 */
export declare function ToDict<T extends SetType, VOut extends (key: Variable<T["value"]>) => EastFunction>(collection: EastFunction<T>, value: VOut): ToDictFunction<DictType<T["value"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends SetType, VOut extends (key: Variable<T["value"]>) => EastFunction, KOut extends (key: Variable<T["value"]>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends SetType, P extends EastType, VOut extends (key: Variable<T["value"]>, initial_value: Variable<P>) => EastFunction, KOut extends (key: Variable<T["value"]>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut, initial_value: EastFunction<P>): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends SetType, P extends Value, VOut extends (key: Variable<T["value"]>, initial_value: Variable<EastTypeOf<P>>) => EastFunction, KOut extends (key: Variable<T["value"]>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut, initial_value: P): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
/**
 * Return a dictionary where each output `key` and `value` is calculated from elements of the input `collection`.
 * If the `key` is `null` the element is ignored. In case of duplicate keys, the last value is kept, unless initial_value
 * is provided in which case the previous value can be used to calculate the new value.
 *
 * @param collection the {@link Expression} for the input array
 * @param value a function from the input value and key (and previous value) to an {@link Expression} to calculate the output value
 * @param key a function from the input value and key to an {@link Expression} to calculate the output key
 * @param initial_value an expression for an initial value given to each key and passed into `value`
 *
 * @category Expression
 *
 * @example
 * ```typescript
 * // create a new dictionary mapping the elements of an array to their uppercase values
 * ToDict(
 *   array,
 *   x => UpperCase(x),
 *   x => x,
 * )
 * ```
 */
export declare function ToDict<T extends ArrayType, VOut extends (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction, KOut extends (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends ArrayType, P extends EastType, VOut extends (value: Variable<T["value"]>, key: Variable<IntegerType>, initial_value: Variable<P>) => EastFunction, KOut extends (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut, initial_value: EastFunction<P>): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends ArrayType, P extends Value, VOut extends (value: Variable<T["value"]>, key: Variable<IntegerType>, initial_value: Variable<EastTypeOf<P>>) => EastFunction, KOut extends (value: Variable<T["value"]>, key: Variable<IntegerType>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut, initial_value: P): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
/**
 * Return a dictionary where each output `key` and `value` is calculated from elements of the input `collection`.
 * If the `key` is `null` the element is ignored. In case of duplicate keys, the last value is kept, unless initial_value
 * is provided in which case the previous value can be used to calculate the new value.
 *
 * @param collection the {@link Expression} for the input dictionary
 * @param value a function from the input value and key (and previous value) to an {@link Expression} to calculate the output value
 * @param key a function from the input value and key to an {@link Expression} to calculate the output key
 * @param initial_value an expression for an initial value given to each key and passed into `value`
 *
 * @category Expression
 * @example
 * ```typescript
 * // create a new dictionary incrementing the integer values of the input dictionary
 * ToDict(
 *   dict,
 *   (value, key) => Add(value, 1n),
 *   (value, key) => key,
 * )
 * ```
 */
export declare function ToDict<T extends DictType, VOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction>(collection: EastFunction<T>, value: VOut): ToDictFunction<DictType<T["value"]["key"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends DictType, VOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction, KOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends DictType, P extends EastType, VOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>, initial_value: Variable<P>) => EastFunction, KOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut, initial_value: EastFunction<P>): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
export declare function ToDict<T extends DictType, P extends Value, VOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>, initial_value: Variable<EastTypeOf<P>>) => EastFunction, KOut extends (value: Variable<T["value"]["value"]>, key: Variable<T["value"]["key"]>) => EastFunction<StringType>>(collection: EastFunction<T>, value: VOut, key: KOut, initial_value: P): ToDictFunction<DictType<ReturnType<KOut>["type"], ReturnType<VOut>["type"]>>;
/**
 * Return the set of keys of `dict`.
 *
 * @param dict the {@link Expression} for the dictionary
 *
 * @category Expression
 *
 * @example
 * ```typescript
 *  // ...
 *  // Given a dictionary from product quantities to price, get the set of product ids
 *  ProductIds: Keys(Variable("ProductQuantities", DictType(IntegerType))),
 *  // ...
 * ```
 */
export declare function Keys<T extends DictType>(dict: EastFunction<T>): KeysFunction<SetType<T["value"]["key"]>>;
/**
 * Return the only key of `dict`, or else `null` if it has zero or more than two elements.
 *
 * @param dict the {@link Expression} for the dictionary
 *
 * @category Expression
 */
export declare function OnlyKey<T extends DictType>(dict: EastFunction<T>): OnlyKeyFunction<Nullable<T["value"]["key"]>>;