/**
 * The {@link StdLib} module provides a set of standard libraries for common {@link Expression} patterns.
 *
 * @module StdLib
 *
 */
import { Expression } from './definition';
import { CalendarUnit, ConstFunction, EastFunction, RoundingMode, TimeUnit, Variable } from './functions';
import { ArrayType, BooleanType, DateTimeType, DictType, EastType, FloatType, IntegerType, Nullable, NullType, NumericType, PrimitiveType, PromoteType, SetType, StringType, StructType, VariantType } from './types';
/**
 * Update an existing field of a struct to a value of the same type.
 *
 * @category StdLib
 *
 * @see {@link Struct}, {@link Spread}
 */
export declare function SetField<T extends StructType, Name extends keyof T["value"]>(struct: EastFunction<T>, name: Name, value: EastFunction<T["value"][Name]>): EastFunction<T>;
/**
 * A helper function to assist in creating large structs.
 * It works identically to how object spreading works in JavaScript.
 * You can use it to either update existing fields in a struct, or to add new fields to a struct.
 *
 * @category StdLib
 *
 * @see {@link Struct}, {@link SetField}
 *
 * @example
 * ```ts
 * // build a struct with an additional field called new_field.
 * vars => Struct({ ...Spread(vars.large_struct), new_field: new_value })
 * ```
 */
export declare function Spread<T extends StructType>(x: EastFunction<T>): {
    [K in keyof T["value"]]: EastFunction<T["value"][K]>;
};
/**
 * Comparison function between two expressions.
 *
 * @category StdLib
 */
export declare function Compare<T extends EastType>(a: Expression<T>, b: Expression<T>): EastFunction<IntegerType>;
/**
 * Return the lesser of `a` and `b` (note that `null` and `NaN` are greater than every other value).
 *
 * @category StdLib
 */
export declare function Min<T extends PrimitiveType, U extends T>(a: Expression<U>, b: Expression<T>): EastFunction<U>;
export declare function Min<T extends PrimitiveType, U extends T>(a: Expression<T>, b: Expression<U>): EastFunction<U>;
/**
 * Return the greater of `a` and `b` (note that `null` and `NaN` are greater than every other value).
 *
 * @category StdLib
 */
export declare function Max<T extends PrimitiveType, U extends T>(a: Expression<U>, b: Expression<T>): EastFunction<U>;
export declare function Max<T extends PrimitiveType, U extends T>(a: Expression<T>, b: Expression<U>): EastFunction<U>;
/**
 * Return true if `value` is `null` or `false` otherwise.
 *
 * @category StdLib
 */
export declare function IsNull(value: EastFunction<EastType>): EastFunction<BooleanType>;
/**
 * Return true if `value` is `null` or `false` otherwise.
 *
 * @category StdLib
 */
export declare function IsNotNull(value: EastFunction<EastType>): EastFunction<BooleanType>;
/**
 * Return an {@link EastType} for the option variant with cases "none" (indicating the lack of data) and "some" (indicating the presence of data).
 *
 * This is an alias for `VariantType({ none: NullType, some: type })`.
 *
 * @param type The `EastType` associated with the "some" case.
 *
 * @see {@link Some}, {@link Unwrap}, {@link MapOption}, {@link Option}.
 *
 * @category StdLib
 **/
export declare function OptionType<T extends EastType>(type: T): VariantType<{
    none: NullType;
    some: T;
}>;
/**
 * Return an {@link EastType} for the Option variant with cases "none" (indicating the lack of data) and "some" (indicating the presence of data).
 *
 * This is an alias for `VariantType({ none: NullType, some: type })`.
 *
 * @param type The `EastType` associated with the "some" case.
 *
 * @see {@link Some}, {@link Unwrap}, {@link None}, {@link MapOption}.
 *
 * @category StdLib
 **/
export type OptionType<T extends EastType = EastType> = VariantType<{
    none: NullType;
    some: T;
}>;
/**
 * An {@link EastFunction} containing the "none" case of the Option variant. This is an alias for `Const(none)`.
 *
 * @see {@link Some}, {@link Unwrap}, {@link MapOption}, {@link OptionType}.
 *
 * @category StdLib
*/
export declare const None: ConstFunction<VariantType<{
    none: NullType;
}>>;
/**
 * Returns an {@link EastFunction} to construct the "some" case of the Option variant with associated data. This is an alias for `Variant("some", value)`.
 *
 * @param data An {@link EastFunction} containing the associated data.
 *
 * @see `None`, `Unrwap`, `MapOption`, `OptionType`, `some`.
 * @category StdLib
*/
export declare function Some<T extends EastType>(data: EastFunction<T>): import("./functions").VariantFunction<VariantType<{
    some: T;
}>>;
/**
 * Returns an {@link EastFunction} to unwrap an Option variant, replacing the "none" case with `defaultValue`.
 *
 * @param value An {@link EastFunction} for the Option variant.
 * @param defaultValue An {@link EastFunction} containing the associated data.
 *
 * @see {@link None}, {@link Some}, {@link MapOption}, {@link OptionType}.
 *
 * @category StdLib
*/
export declare function Unwrap<T extends EastType, U extends T>(value: EastFunction<OptionType<T>>, defaultValue: EastFunction<U>): EastFunction<T & U>;
export declare function Unwrap<T extends EastType, U extends T>(value: EastFunction<OptionType<U>>, defaultValue: EastFunction<T>): EastFunction<T & U>;
/**
 * Returns an {@link EastFunction} to map the data corresponding to the "some" case an Option variant through a function, while leaving the "none" case alone.
 *
 * @param value An {@link EastFunction} for the Option variant.
 * @param f A function of data associated with the "some" case returning an {@link EastFunction} for the new associated data.
 *
 * @see {@link None}, {@link Some}, {@link Unwrap}, {@link OptionType}.
 *
 * @category StdLib
*/
export declare function MapOption<T extends EastType, F extends (data: Variable<T>) => EastFunction>(value: EastFunction<OptionType<T>>, f: F): EastFunction<OptionType<ReturnType<F>["type"]>>;
/**
 * Returns a  {@link StringType} {@link EastFunction} for the tag of a {@link VariantType} {@link EastFunction}.
 *
 * @param value An {@link EastFunction} for the Option variant.
 *
 * @category StdLib
*/
export declare function GetTag<Variants extends Record<string, EastType>, Fs extends {
    [K in keyof Variants]: ((v: Variable<Variants[K]>) => EastFunction);
}>(value: EastFunction<VariantType<Variants>>): EastFunction<StringType>;
/**
 * Returns a {@link BooleanType} to determine if the tag of a {@link VariantType} {@link EastFunction} matches a supplied value.
 *
 * @param value An {@link EastFunction} for the Option variant.
 * @param tag the variant case (or tag) to test against
 *
 * @category StdLib
*/
export declare function HasTag<T extends VariantType, Tag extends keyof T["value"]>(value: EastFunction<T>, tag: Tag): EastFunction<BooleanType>;
/**
 * Returns a {@link EastType} to based on provided tag of a {@link VariantType} {@link EastFunction}.
 *
 * @param value An {@link EastFunction} for the Option variant.
 * @param tag the variant case (or tag) to test against
 * @param f the expression of the variant value
 * @param defaultValue the default value when the variant doesn't hag the tag
 *
 * @category StdLib
*/
export declare function MatchTag<T extends VariantType, Tag extends keyof T["value"], R extends EastType, Fs extends (v: Variable<T["value"][Tag]>) => EastFunction<R>>(value: EastFunction<T>, tag: Tag, f: Fs, defaultValue: EastFunction<R>): EastFunction<R>;
/**
 * Filter and map a collection (array or dictionary) of variants, keeping just one variant
 * case (or tag) and unwrapping the associated data.
 *
 * @param collection an {@link Expression} for a collection of variants
 * @param tag the variant case (or tag) to keep and unwrap
 *
 * @category StdLib
 */
export declare function FilterTag<T extends VariantType, Tag extends keyof T["value"], K extends StringType>(collection: EastFunction<DictType<K, T>>, tag: Tag): EastFunction<DictType<K, T["value"][Tag]>>;
export declare function FilterTag<T extends VariantType, Tag extends keyof T["value"]>(collection: EastFunction<ArrayType<T>>, tag: Tag): EastFunction<ArrayType<T["value"][Tag]>>;
/**
 * Pad the start of a string with a character up to a certain total length.
 *
 * @remarks it is assumed that `char` has length 1.
 *
 * @category StdLib
 */
export declare function PadStart(value: EastFunction<StringType>, char: EastFunction<StringType> | string, n: EastFunction<IntegerType> | bigint): EastFunction<StringType>;
/**
 * Pad the end of a string with a character up to a certain total length.
 *
 * @remarks it is assumed that `char` has length 1.
 *
 * @category StdLib
 */
export declare function PadEnd(value: EastFunction<StringType>, char: EastFunction<StringType> | string, n: EastFunction<IntegerType> | bigint): EastFunction<StringType>;
/**
 * Round datetime `value` down to a whole time `unit` ("year", "month", "week", "day", "hour", "minute", "second").
 *
 * @category StdLib
 */
export declare function Floor<T extends DateTimeType>(value: EastFunction<T>, unit: TimeUnit | CalendarUnit): EastFunction<T>;
/**
 * Round number `value` down to nearest integer
 *
 * @category StdLib
 */
export declare function Floor<T extends FloatType>(value: EastFunction<T>, type: 'integer'): EastFunction<T extends NullType ? Nullable<IntegerType> : IntegerType>;
/**
 * Round number `value` down to a whole number.
 *
 * @category StdLib
 */
export declare function Floor<T extends FloatType>(value: EastFunction<T>, type?: 'float'): EastFunction<T>;
/**
 * Round datetime `value` up to a whole time `unit` ("year", "month", "week", "day", "hour", "minute", "second").
 *
 * @category StdLib
 */
export declare function Ceiling<T extends DateTimeType>(value: EastFunction<T>, unit: TimeUnit | CalendarUnit): EastFunction<T>;
/**
 * Round number `value` up to a whole number.
 *
 * @category StdLib
 */
export declare function Ceiling<T extends FloatType>(value: EastFunction<T>, type?: 'float'): EastFunction<T>;
/**
 * Round number `value` up to nearest integer.
 *
 * @category StdLib
 */
export declare function Ceiling<T extends FloatType>(value: EastFunction<T>, type?: 'integer'): EastFunction<T extends NullType ? Nullable<IntegerType> : IntegerType>;
/**
 * Round number `value` up to nearest multiple of `divisor`.
 *
 * @category StdLib
 */
export declare function RoundMultiple<T extends FloatType>(value: EastFunction<T>, divisor: EastFunction<T>, rounding_mode?: RoundingMode | undefined): EastFunction<T extends NullType ? Nullable<T> : T>;
/**
 * Round number `value` towards zero to a whole number.
 *
 * @category StdLib
 */
export declare function Truncate<T extends FloatType>(value: EastFunction<T>, type?: 'float'): EastFunction<T>;
/**
 * Round number `value` towards zero to the nearest integer.
 *
 * @category StdLib
 */
export declare function Truncate<T extends FloatType>(value: EastFunction<T>, type?: 'integer'): EastFunction<T extends NullType ? Nullable<IntegerType> : IntegerType>;
/**
 * Return a random number drawn from an exponential distribution.
 *
 * @category StdLib
 */
export declare function RandomExponential(): EastFunction<FloatType>;
/**
 * Return a random number drawn from the Weibull distribution.
 *
 * @category StdLib
 */
export declare function RandomWeibull(shape: EastFunction<FloatType>): EastFunction<FloatType>;
/**
 * Return a random subset of at most `n` keys from the input `collection`.
 *
 * @category StdLib
 */
export declare function RandomKeys<T extends StringType>(collection: EastFunction<DictType<T>>, n: EastFunction<IntegerType>): EastFunction<SetType<T>>;
export declare function RandomKeys<T extends StringType>(collection: EastFunction<SetType<T>>, n: EastFunction<IntegerType>): EastFunction<SetType<T>>;
export declare function RandomKeys(collection: EastFunction<ArrayType>, n: EastFunction<IntegerType>): EastFunction<ArrayType<IntegerType>>;
/**
 * Return a random subset of at most `n` values from the input `collection` (using sampling without replacement).
 *
 * @category StdLib
 */
export declare function RandomValues<I extends EastType>(collection: EastFunction<DictType<StringType, I>>, n: EastFunction<IntegerType>): EastFunction<DictType<StringType, I>>;
export declare function RandomValues<I extends EastType>(collection: EastFunction<ArrayType<I>>, n: EastFunction<IntegerType>): EastFunction<ArrayType<I>>;
/**
 * Return the number of whole weeks elapsed since the first Monday prior to or of the first day of the month.
 *
 * @category StdLib
 */
export declare function WeekOfMonth(date: EastFunction<DateTimeType>): EastFunction<IntegerType>;
/**
 * Convert a float {@link DictType} to an integer {@link DictType}.
 *
 * @category StdLib
 */
export declare function ConvertFloatDict(dict: EastFunction<DictType<StringType, FloatType>>): EastFunction<DictType<StringType, IntegerType>>;
/**
 * Convert an integer {@link DictType} to an float {@link DictType}.
 *
 * @category StdLib
 */
export declare function ConvertIntegerDict(dict: EastFunction<DictType<StringType, IntegerType>>): EastFunction<DictType<StringType, FloatType>>;
/**
 * Convert a number {@link Expression} to a magnitude string between ['negligible', 'moderate', 'large'].
 *
 * @category StdLib
 */
export declare function Importance(domain: Expression<FloatType>, range?: [negligible: number, moderate: number]): EastFunction<StringType>;
/**
 * Return a comma seperated and rounded currency string from an integer.
 *
 * @category StdLib
 */
export declare function PrintTruncatedCurrency(value: Expression<IntegerType>): EastFunction<StringType>;
/**
 * Return a comma seperated and rounded currency string from a number.
 *
 * @category StdLib
 */
export declare function PrintTruncatedCurrency(value: Expression<FloatType>): EastFunction<StringType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Monday.
 *
 * @category StdLib
 */
export declare function IsMonday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Tuesday.
 *
 * @category StdLib
 */
export declare function IsTuesday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Wednesday.
 *
 * @category StdLib
 */
export declare function IsWednesday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Thursday.
 *
 * @category StdLib
 */
export declare function IsThursday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Friday.
 *
 * @category StdLib
 */
export declare function IsFriday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Saturday.
 *
 * @category StdLib
 */
export declare function IsSaturday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a Sunday.
 *
 * @category StdLib
 */
export declare function IsSunday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a weekend.
 *
 * @category StdLib
 */
export declare function IsWeekend(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return the a boolean function to determine if a datetime {@link Expression} falls on a weekday.
 *
 * @category StdLib
 */
export declare function IsWeekday(date: EastFunction<DateTimeType>): EastFunction<BooleanType>;
/**
 * Return a {@link Print} function to convert a datetime {@link Expression} to a day of week name.
 *
 * @category StdLib
 */
export declare function DayName(date: EastFunction<DateTimeType | IntegerType>): import("./functions").GetFunction<StringType>;
/**
 * Return a {@link Print} function to convert a day of week {@link Expression} to a day of week name.
 *
 * @category StdLib
 */
export declare function DayInteger(day_name: EastFunction<StringType>): import("./functions").GetFunction<IntegerType>;
/**
 * Return a {@link Print} function to convert a datetime {@link Expression} to an abbreviated day of week name.
 *
 * @category StdLib
 */
export declare function DayNameShort(date: EastFunction<DateTimeType | IntegerType>): import("./functions").GetFunction<StringType>;
/**
 * Return a {@link Print} function to convert a datetime {@link Expression} to an abbreviated month name.
 *
 * @category StdLib
 */
export declare function MonthNameShort(date: EastFunction<DateTimeType>): import("./functions").GetFunction<StringType>;
/**
 * Return `value` unless it equals `from`, in which case replace it with `to`.
 *
 * @category StdLib
 */
export declare function Replace<T extends PrimitiveType, U extends T, V extends T>(value: EastFunction<T>, from: Expression<U>, to: Expression<V>): EastFunction<T>;
export declare function Replace<T extends EastType, U extends T, V extends T>(value: EastFunction<T>, from: null, to: Expression<V>): EastFunction<T>;
/**
 * Return `true` if `collection` has zero elements, or `false` otherwise.
 *
 * @category StdLib
 */
export declare function IsEmpty(collection: EastFunction<SetType | DictType>): EastFunction<BooleanType>;
/**
 * Return the absolute value of a number or integer {@link Expression}.
 *
 * @category StdLib
 */
export declare function Abs(x: Expression<IntegerType>): EastFunction<IntegerType>;
export declare function Abs(x: Expression<FloatType>): EastFunction<FloatType>;
/**
 * Add all collection values into a single float or integer {@link Expression}.
 *
 * @category StdLib
 */
export declare function AddAll(collection: EastFunction<ArrayType<FloatType>>): EastFunction<FloatType>;
export declare function AddAll(collection: EastFunction<ArrayType<IntegerType>>): EastFunction<IntegerType>;
export declare function AddAll(collection: EastFunction<DictType<StringType, FloatType>>): EastFunction<FloatType>;
export declare function AddAll(collection: EastFunction<DictType<StringType, IntegerType>>): EastFunction<IntegerType>;
/**
 * Union all sets in `collection` into a single set {@link Expression}.
 *
 * @category StdLib
 */
export declare function UnionAll<T extends SetType>(collection: EastFunction<ArrayType<T> | DictType<StringType, T>>): EastFunction<T>;
/**
 * Return a {@link Print} function to convert a cycle {@link Expression} to an abbreviated week description.
 *
 * @category StdLib
 */
export declare function WeekDescription(cycle: EastFunction<IntegerType>): EastFunction<StringType>;
/**
 * Print a number with a seperator between the thousands, e.g. 1234 as "1,234"
 *
 * @category StdLib
 */
export declare function PrintSeperated(x: Expression<IntegerType | FloatType>, thousands_seperator: string): EastFunction<StringType>;
/**
 * Return a {@link ArrayType} {@link EastFunction} to convert a dictionary into an array of key & value pairs
 *
 * @category StdLib
 */
export declare function ToEntries<T extends EastType>(dict: EastFunction<DictType<StringType, T>>): EastFunction<ArrayType<StructType<{
    Key: StringType;
    Value: T;
}>>>;
/**
 * Return a number {@link EastFunction} to peform ...
 *
 * @category StdLib
 */
export declare function Sigmoid<T extends FloatType>(x: EastFunction<T>): EastFunction<T>;
/**
 * Convenience function to convert a datetime into a string for a key, rounding optional.
 *
 * @category StdLib
 */
export declare function DateKey(value: EastFunction<DateTimeType>, unit?: TimeUnit | CalendarUnit): EastFunction<StringType>;
/**
 * Convenience function to convert one or more expressions into a string for a key.
 *
 * @category StdLib
 */
export declare function PrimaryKey(...values: EastFunction<PrimitiveType>[]): EastFunction<StringType>;
/**
 * Multiply `first` by `second` where both are dictionaries.
 *
 * @param first the first {@link Expression} to multiply
 * @param second the second {@link Expression} to multiply
 *
 * @category StdLib
 *
 * @example
 * ```typescript
 *  // ...
 *  // return the products revenue by multiplying the prices by the qtys
 *  Amounts: MultiplyDict(
 *      Variable('UnitPrices', DictType(StringType, FloatType)),
 *      Variable('Quantities', DictType(StringType, FloatType))
 *  ),
 *  // ...
 * ```
 */
export declare function MultiplyDict<X extends FloatType | IntegerType, Y extends FloatType | IntegerType>(first: Expression<DictType<StringType, X>>, second: Expression<DictType<StringType, Y>>): EastFunction<DictType<StringType, PromoteType<X, Y>>>;
/**
 * Add `first` to `second` where both are dictionaries.
 *
 * @param first the first {@link Expression} to add
 * @param second the second {@link Expression} to add
 *
 * @remarks Missing keys between first and second are assumed to have a value of 0.
 *
 * @category StdLib
 *
 * @example
 * ```typescript
 *  // ...
 *  // return the prices by dividing the total amounts by the qtys
 *  NewBalance: AddDict(
 *      Variable('InitialBalance', DictType(StringType, FloatType)),
 *      Variable('Amount', DictType(StringType, FloatType))
 *  ),
 *  // ...
 * ```
 */
export declare function AddDict<T extends NumericType>(d1: EastFunction<DictType<StringType, T>>, d2: EastFunction<DictType<StringType, T>>): import("./functions").MapValuesFunction<DictType<StringType, any>>;