import { JsonDecoder, JsonEncoder } from './json';
import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, EastType, FloatType, IntegerType, JsonValue, Nullable, NullType, SetType, StringType, StructType, Value, ValueTypeOf, VariantType } from './types';
/**
 * A unit of time.
 *
 * @category Utility
 */
export type TimeUnit = "millisecond" | "second" | "minute" | "hour" | "day" | "week";
/** @internal */
export type TimeSpan = {
    value: number;
    unit: TimeUnit;
};
/**
 * A span of time.
 * @param value: the length of the `TimeSpan`
 * @param unit: the units of the `TimeSpan`
 * @returns The `TimeSpan` definition
 *
 * @category Utility
 *
 * @example
 * ```typescript
 * //Create a timespan of one hour.
 * const timespan = TimeSpan(1, 'hour')
 * ```
 */
export declare function TimeSpan(value: number, unit?: TimeUnit): {
    value: number;
    unit: TimeUnit;
};
/**
 * A unit of calendar time.
 *
 * @category Utility
 */
export type CalendarUnit = "month" | "year";
/**
 * Denotes a function returning {@link EastType}.
 *
 * @category Expression
 */
export type EastFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: AstType;
};
/** @internal */
export type AstType = "Variable" | "Const" | "Let" | "Procedure" | "ML" | "IfNull" | "IfElse" | "Convert" | "Parse" | "Print" | "Not" | "And" | "Or" | "Equal" | "NotEqual" | "Less" | "LessEqual" | "Greater" | "GreaterEqual" | "Add" | "Subtract" | "Multiply" | "Divide" | "Modulo" | "Round" | "RoundPrecision" | "Sqrt" | "Log" | "Exp" | "Sin" | "Cos" | "Tan" | "Pow" | "RandomUniform" | "RandomNormal" | "RandomRange" | "RandomValue" | "RandomKey" | "RandomWeightedKey" | "ToDateTime" | "Duration" | "AddDuration" | "SubtractDuration" | "TimeZoneConvert" | "Millisecond" | "Second" | "Minute" | "Hour" | "DayOfWeek" | "DayOfMonth" | "Month" | "Year" | "Substring" | "Repeat" | "StringJoin" | "RegexReplace" | "RegexContains" | "UpperCase" | "LowerCase" | "ToCsv" | "FromCsv" | "ToJson" | "FromJson" | "Hash" | "HMAC" | "Base64ToAscii" | "AsciiToBase64" | "Base64ToHex" | "HexToBase64" | "URIEncode" | "URIDecode" | "In" | "SubsetEqual" | "Union" | "Intersect" | "SetDiff" | "SymDiff" | "Keys" | "OnlyKey" | "Get" | "NewSet" | "NewDict" | "NewArray" | "Range" | "ToSet" | "ToArray" | "ToDict" | "Insert" | "Update" | "Delete" | "Size" | "Filter" | "MapDict" | "FilterMap" | "Reduce" | "Sort" | "Struct" | "GetField" | "Variant" | "Match" | "Utf8Encode" | "Utf8Decode";
/** @internal */
export type Variable<T extends EastType = EastType> = {
    type: T;
    ast_type: "Variable";
    name: string;
};
/** @internal */
export declare function isVariable<T extends EastType>(f: EastFunction<T>): f is Variable<T>;
/**
 * Denotes a variable with a given name and data type.
 *
 * @category Expression
 */
export declare function Variable<T extends EastType>(name: string, type: T): Variable<T>;
/** @internal */
export type ConstFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Const";
    value: JsonValue;
    decoded?: ValueTypeOf<T> | undefined;
};
/** @internal */
export declare function isConstFunction<T extends EastType>(f: EastFunction<T>): f is ConstFunction<T>;
/** @internal */
export type LetFunction<T extends EastType = EastType, U extends EastType = EastType> = {
    type: T;
    ast_type: "Let";
    ast: EastFunction<T>;
    variable: Variable<U>;
    value: EastFunction<U>;
};
/** @internal */
export declare function isLetFunction<T extends EastType>(f: EastFunction<T>): f is LetFunction<T>;
/** @internal */
export type ProcedureFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Procedure";
    name: string;
    inputs: EastFunction<StructType>;
};
/** @internal */
export declare function isProcedureFunction<T extends EastType>(f: EastFunction<T>): f is ProcedureFunction<T>;
/** @internal */
export type MLFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "ML";
    name: string;
    features: EastFunction<StructType>;
    config: Record<string, EastFunction>;
};
/** @internal */
export declare function isMLFunction<T extends EastType>(f: EastFunction<T>): f is MLFunction<T>;
/** @internal */
export type IfNullFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "IfNull";
    input: EastFunction<Nullable>;
    output_null: EastFunction<T>;
    output_value: EastFunction<T>;
    value?: Variable | undefined;
};
/** @internal */
export declare function isIfNullFunction<T extends EastType>(f: EastFunction<T>): f is IfNullFunction<T>;
/** @internal */
export type IfElseFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "IfElse";
    predicate: EastFunction<BooleanType>;
    true: EastFunction<T>;
    false: EastFunction<T>;
};
/** @internal */
export declare function isIfElseFunction<T extends EastType>(f: EastFunction<T>): f is IfElseFunction<T>;
/** @internal */
export type ConvertFunction<T extends EastType = EastType, U extends EastType = EastType> = {
    type: T;
    ast_type: "Convert";
    from: EastFunction<U>;
};
/** @internal */
export declare function isConvertFunction<T extends EastType>(f: EastFunction<T>): f is ConvertFunction<T>;
/** @internal */
export type ParseFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Parse";
    from: EastFunction<StringType>;
    format?: string | undefined;
};
/** @internal */
export declare function isParseFunction<T extends EastType>(f: EastFunction<T>): f is ParseFunction<T>;
/** @internal */
export type PrintFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Print";
    value: EastFunction;
    format?: string | undefined;
};
/** @internal */
export declare function isPrintFunction<T extends EastType>(f: EastFunction<T>): f is PrintFunction<T>;
/** @internal */
export type NotFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Not";
    value: EastFunction<BooleanType>;
};
/** @internal */
export declare function isNotFunction<T extends EastType>(f: EastFunction<T>): f is NotFunction<T>;
/** @internal */
export type AndFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "And";
    first: EastFunction<BooleanType>;
    second: EastFunction<BooleanType>;
};
/** @internal */
export declare function isAndFunction<T extends EastType>(f: EastFunction<T>): f is AndFunction<T>;
/** @internal */
export type OrFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Or";
    first: EastFunction<BooleanType>;
    second: EastFunction<BooleanType>;
};
/** @internal */
export declare function isOrFunction<T extends EastType>(f: EastFunction<T>): f is OrFunction<T>;
/** @internal */
export type EqualFunction<Out extends EastType = EastType> = {
    type: Out;
    ast_type: "Equal";
    first: EastFunction;
    second: EastFunction;
    compiled?: ((first: Value, second: Value) => boolean) | undefined;
};
/** @internal */
export declare function isEqualFunction<T extends EastType>(f: EastFunction<T>): f is EqualFunction<T>;
/** @internal */
export type NotEqualFunction<Out extends EastType = EastType, In extends EastType = EastType> = {
    type: Out;
    ast_type: "NotEqual";
    first: EastFunction<In>;
    second: EastFunction<In>;
    compiled?: ((first: Value, second: Value) => boolean) | undefined;
};
/** @internal */
export declare function isNotEqualFunction<T extends EastType>(f: EastFunction<T>): f is NotEqualFunction<T>;
/** @internal */
export type LessFunction<Out extends EastType = EastType, In extends EastType = EastType> = {
    type: Out;
    ast_type: "Less";
    first: EastFunction<In>;
    second: EastFunction<In>;
    compiled?: ((first: Value, second: Value) => boolean) | undefined;
};
/** @internal */
export declare function isLessFunction<T extends EastType>(f: EastFunction<T>): f is LessFunction<T>;
/** @internal */
export type LessEqualFunction<Out extends EastType = EastType, In extends EastType = EastType> = {
    type: Out;
    ast_type: "LessEqual";
    first: EastFunction<In>;
    second: EastFunction<In>;
    compiled?: ((first: Value, second: Value) => boolean) | undefined;
};
/** @internal */
export declare function isLessEqualFunction<T extends EastType>(f: EastFunction<T>): f is LessEqualFunction<T>;
/** @internal */
export type GreaterFunction<Out extends EastType = EastType, In extends EastType = EastType> = {
    type: Out;
    ast_type: "Greater";
    first: EastFunction<In>;
    compiled?: ((first: Value, second: Value) => boolean) | undefined;
    second: EastFunction<In>;
};
/** @internal */
export declare function isGreaterFunction<T extends EastType>(f: EastFunction<T>): f is GreaterFunction<T>;
/** @internal */
export type GreaterEqualFunction<Out extends EastType = EastType, In extends EastType = EastType> = {
    type: Out;
    ast_type: "GreaterEqual";
    first: EastFunction<In>;
    second: EastFunction<In>;
    compiled?: ((first: Value, second: Value) => boolean);
};
/** @internal */
export declare function isGreaterEqualFunction<T extends EastType>(f: EastFunction<T>): f is GreaterEqualFunction<T>;
/** @internal */
export type AddFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Add";
    first: EastFunction<FloatType | IntegerType>;
    second: EastFunction<FloatType | IntegerType>;
};
/** @internal */
export declare function isAddFunction<T extends EastType>(f: EastFunction<T>): f is AddFunction<T>;
/** @internal */
export type SubtractFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Subtract";
    first: EastFunction<FloatType | IntegerType>;
    second: EastFunction<FloatType | IntegerType>;
};
/** @internal */
export declare function isSubtractFunction<T extends EastType>(f: EastFunction<T>): f is SubtractFunction<T>;
/** @internal */
export type MultiplyFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Multiply";
    first: EastFunction<FloatType | IntegerType>;
    second: EastFunction<FloatType | IntegerType>;
};
/** @internal */
export declare function isMultiplyFunction<T extends EastType>(f: EastFunction<T>): f is MultiplyFunction<T>;
/** @internal */
export type DivideFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Divide";
    first: EastFunction<FloatType>;
    second: EastFunction<FloatType>;
};
/** @internal */
export declare function isDivideFunction<T extends EastType>(f: EastFunction<T>): f is DivideFunction<T>;
/** @internal */
export type ModuloFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Modulo";
    first: EastFunction<FloatType | IntegerType>;
    second: EastFunction<IntegerType>;
};
/** @internal */
export declare function isModuloFunction<T extends EastType>(f: EastFunction<T>): f is ModuloFunction<T>;
/**
 * A mode to apply in rounding
 *
 * @category Expression
 */
export type RoundingMode = "nearest" | "floor" | "ceiling" | "truncate";
/** @internal */
export type RoundFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Round";
    rounding_mode: RoundingMode;
    value: EastFunction<T>;
    unit?: TimeUnit | CalendarUnit | undefined;
};
/** @internal */
export declare function isRoundFunction<T extends EastType>(f: EastFunction<T>): f is RoundFunction<T>;
/** @internal */
export type RoundPrecisionFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RoundPrecision";
    value: EastFunction<T>;
    significant_digits: number;
};
/** @internal */
export declare function isRoundPrecisionFunction<T extends EastType>(f: EastFunction<T>): f is RoundFunction<T>;
/** @internal */
export type SqrtFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Sqrt";
    value: EastFunction<FloatType>;
};
/** @internal */
export declare function isSqrtFunction<T extends EastType>(f: EastFunction<T>): f is SqrtFunction<T>;
/** @internal */
export type LogFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Log";
    value: EastFunction<FloatType>;
};
/** @internal */
export declare function isLogFunction<T extends EastType>(f: EastFunction<T>): f is LogFunction<T>;
/** @internal */
export type ExpFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Exp";
    value: EastFunction<FloatType>;
};
/** @internal */
export declare function isExpFunction<T extends EastType>(f: EastFunction<T>): f is ExpFunction<T>;
/** @internal */
export type SinFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Sin";
    value: EastFunction<FloatType>;
};
/** @internal */
export declare function isSinFunction<T extends EastType>(f: EastFunction<T>): f is ExpFunction<T>;
/** @internal */
export type CosFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Cos";
    value: EastFunction<FloatType>;
};
/** @internal */
export declare function isCosFunction<T extends EastType>(f: EastFunction<T>): f is ExpFunction<T>;
/** @internal */
export type TanFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Tan";
    value: EastFunction<FloatType>;
};
/** @internal */
export declare function isTanFunction<T extends EastType>(f: EastFunction<T>): f is ExpFunction<T>;
/** @internal */
export type PowFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Pow";
    first: EastFunction<FloatType>;
    second: EastFunction<FloatType>;
};
/** @internal */
export declare function isPowFunction<T extends EastType>(f: EastFunction<T>): f is PowFunction<T>;
/** @internal */
export type RandomUniformFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RandomUniform";
};
/** @internal */
export declare function isRandomUniformFunction<T extends EastType>(f: EastFunction<T>): f is RandomUniformFunction<T>;
/** @internal */
export type RandomNormalFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RandomNormal";
};
/** @internal */
export declare function isRandomNormalFunction<T extends EastType>(f: EastFunction<T>): f is RandomNormalFunction<T>;
/** @internal */
export type RandomRangeFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RandomRange";
    min: EastFunction<IntegerType>;
    max: EastFunction<IntegerType>;
};
/** @internal */
export declare function isRandomRangeFunction<T extends EastType>(f: EastFunction<T>): f is RandomRangeFunction<T>;
/** @internal */
export type RandomKeyFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RandomKey";
    collection: EastFunction<ArrayType | DictType | SetType>;
    def: EastFunction;
};
/** @internal */
export declare function isRandomKeyFunction<T extends EastType>(f: EastFunction<T>): f is RandomKeyFunction<T>;
/** @internal */
export type RandomValueFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RandomValue";
    collection: EastFunction<ArrayType | DictType>;
    def: EastFunction;
};
/** @internal */
export declare function isRandomValueFunction<T extends EastType>(f: EastFunction<T>): f is RandomValueFunction<T>;
/** @internal */
export type RandomWeightedKeyFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RandomWeightedKey";
    collection: EastFunction<DictType<StringType, FloatType> | ArrayType<FloatType>>;
    def: EastFunction;
};
/** @internal */
export declare function isRandomWeightedKeyFunction<T extends EastType>(f: EastFunction<T>): f is RandomWeightedKeyFunction<T>;
/** @internal */
export type ToDateTimeFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "ToDateTime";
    value: EastFunction<StringType>;
    format?: string | undefined;
};
/** @internal */
export declare function isToDateTimeFunction<T extends EastType>(f: EastFunction<T>): f is ToDateTimeFunction<T>;
/** @internal */
export type DurationFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Duration";
    start: EastFunction<DateTimeType>;
    stop: EastFunction<DateTimeType>;
    unit: TimeUnit;
};
/** @internal */
export declare function isDurationFunction<T extends EastType>(f: EastFunction<T>): f is DurationFunction<T>;
/** @internal */
export type AddDurationFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "AddDuration";
    start: EastFunction<DateTimeType>;
    duration: EastFunction<FloatType>;
    unit: TimeUnit;
};
/** @internal */
export declare function isAddDurationFunction<T extends EastType>(f: EastFunction<T>): f is AddDurationFunction<T>;
/** @internal */
export type SubtractDurationFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "SubtractDuration";
    start: EastFunction<DateTimeType>;
    duration: EastFunction<FloatType>;
    unit: TimeUnit;
};
/** @internal */
export declare function isSubtractDurationFunction<T extends EastType>(f: EastFunction<T>): f is SubtractDurationFunction<T>;
/** @internal */
export type TimeZoneConvertFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "TimeZoneConvert";
    input: EastFunction<DateTimeType>;
    input_timezone: EastFunction<StringType>;
    output_timezone: EastFunction<StringType>;
};
/** @internal */
export declare function isTimeZoneConvertFunction<T extends EastType>(f: EastFunction<T>): f is TimeZoneConvertFunction<T>;
/** @internal */
export type MillisecondFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Millisecond";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isMillisecondFunction<T extends EastType>(f: EastFunction<T>): f is MillisecondFunction<T>;
/** @internal */
export type SecondFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Second";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isSecondFunction<T extends EastType>(f: EastFunction<T>): f is SecondFunction<T>;
/** @internal */
export type MinuteFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Minute";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isMinuteFunction<T extends EastType>(f: EastFunction<T>): f is MinuteFunction<T>;
/** @internal */
export type HourFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Hour";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isHourFunction<T extends EastType>(f: EastFunction<T>): f is HourFunction<T>;
/** @internal */
export type DayOfWeekFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "DayOfWeek";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isDayOfWeekFunction<T extends EastType>(f: EastFunction<T>): f is DayOfWeekFunction<T>;
/** @internal */
export type DayOfMonthFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "DayOfMonth";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isDayOfMonthFunction<T extends EastType>(f: EastFunction<T>): f is DayOfMonthFunction<T>;
/** @internal */
export type MonthFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Month";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isMonthFunction<T extends EastType>(f: EastFunction<T>): f is MonthFunction<T>;
/** @internal */
export type YearFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Year";
    datetime: EastFunction<DateTimeType>;
};
/** @internal */
export declare function isYearFunction<T extends EastType>(f: EastFunction<T>): f is YearFunction<T>;
/** @internal */
export type SubstringFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Substring";
    value: EastFunction<StringType>;
    start: number;
    stop: number;
};
/** @internal */
export declare function isSubstringFunction<T extends EastType>(f: EastFunction<T>): f is SubstringFunction<T>;
/** @internal */
export type RepeatFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Repeat";
    value: EastFunction<StringType>;
    n: EastFunction<IntegerType>;
};
/** @internal */
export declare function isRepeatFunction<T extends EastType>(f: EastFunction<T>): f is RepeatFunction<T>;
/** @internal */
export type StringJoinFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "StringJoin";
    values: EastFunction<StringType>[];
    seperator: string;
};
/** @internal */
export declare function isStringJoinFunction<T extends EastType>(f: EastFunction<T>): f is StringJoinFunction<T>;
/** @internal */
export type RegexReplaceFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "RegexReplace";
    value: EastFunction<StringType>;
    search: string;
    replace: EastFunction<StringType>;
    flags: string;
    regex?: RegExp | undefined;
};
/** @internal */
export declare function isRegexReplaceFunction<T extends EastType>(f: EastFunction<T>): f is RegexReplaceFunction<T>;
/** @internal */
export type RegexContainsFunction<T extends EastType = EastType> = {
    ast_type: "RegexContains";
    type: T;
    value: EastFunction<StringType>;
    search: string;
    flags: string;
    regex?: RegExp | undefined;
};
/** @internal */
export declare function isRegexContainsFunction<T extends EastType>(f: EastFunction<T>): f is RegexContainsFunction<T>;
/** @internal */
export type UpperCaseFunction<T extends EastType = EastType> = {
    ast_type: "UpperCase";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isUpperCaseFunction<T extends EastType>(f: EastFunction<T>): f is UpperCaseFunction<T>;
/** @internal */
export type LowerCaseFunction<T extends EastType = EastType> = {
    ast_type: "LowerCase";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isLowerCaseFunction<T extends EastType>(f: EastFunction<T>): f is LowerCaseFunction<T>;
/** internal */
export type ToCsvOptions = {
    nullString: string | null;
    quoteChar: string;
    escapeChar: string;
    delimiter: string;
    newline: string;
    header: boolean;
};
/** @internal */
export type ToCsvFunction<T extends EastType = EastType> = {
    ast_type: "ToCsv";
    type: T;
    value: EastFunction<ArrayType<StructType>>;
    printers: Record<string, EastFunction<StringType>>;
    options: ToCsvOptions;
};
/** @internal */
export declare function isToCsvFunction<T extends EastType>(f: EastFunction<T>): f is ToCsvFunction<T>;
/** internal */
export type FromCsvOptions = {
    nullString: string | null;
    quoteChar: string;
    escapeChar: string;
    delimiter: string[];
    newline: string[];
    header: boolean;
};
/** @internal */
export type FromCsvFunction<T extends EastType = EastType> = {
    ast_type: "FromCsv";
    type: T;
    value: EastFunction<BlobType>;
    parsers: Record<string, EastFunction>;
    options: FromCsvOptions;
};
/** @internal */
export declare function isFromCsvFunction<T extends EastType>(f: EastFunction<T>): f is FromCsvFunction<T>;
/** @internal */
export type ToJsonFunction<T extends EastType = EastType> = {
    ast_type: "ToJson";
    type: T;
    value: EastFunction;
    encoder?: JsonEncoder<EastType> | undefined;
};
/** @internal */
export declare function isToJsonFunction<T extends EastType>(f: EastFunction<T>): f is ToJsonFunction<T>;
/** @internal */
export type FromJsonFunction<T extends EastType = EastType> = {
    ast_type: "FromJson";
    type: T;
    value: EastFunction<StringType>;
    decoder?: JsonDecoder<EastType> | undefined;
};
/** @internal */
export declare function isFromJsonFunction<T extends EastType>(f: EastFunction<T>): f is FromJsonFunction<T>;
/**
 * A type of hashing algorithm.
 *
 * @category Expression
 */
export type HashType = "md5" | "sha1" | "sha256";
/** @internal */
export type HashFunction<T extends EastType = EastType> = {
    ast_type: "Hash";
    type: T;
    value: EastFunction<StringType>;
    hash: HashType;
    encoding: "base64" | "hex";
};
/** @internal */
export declare function isHashFunction<T extends EastType>(f: EastFunction<T>): f is HashFunction<T>;
/** @internal */
export type HMACFunction<T extends EastType = EastType> = {
    ast_type: "HMAC";
    type: T;
    value: EastFunction<StringType>;
    key: EastFunction<StringType>;
    hash: HashType;
    encoding: "base64" | "hex";
};
/** @internal */
export declare function isHMACFunction<T extends EastType>(f: EastFunction<T>): f is HMACFunction<T>;
/** @internal */
export type Base64ToAsciiFunction<T extends EastType = EastType> = {
    ast_type: "Base64ToAscii";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isBase64ToAsciiFunction<T extends EastType>(f: EastFunction<T>): f is Base64ToAsciiFunction<T>;
/** @internal */
export type AsciiToBase64Function<T extends EastType = EastType> = {
    ast_type: "AsciiToBase64";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isAsciiToBase64Function<T extends EastType>(f: EastFunction<T>): f is AsciiToBase64Function<T>;
/** @internal */
export type Base64ToHexFunction<T extends EastType = EastType> = {
    ast_type: "Base64ToHex";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isBase64ToHexFunction<T extends EastType>(f: EastFunction<T>): f is Base64ToHexFunction<T>;
/** @internal */
export type HexToBase64Function<T extends EastType = EastType> = {
    ast_type: "HexToBase64";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isHexToBase64Function<T extends EastType>(f: EastFunction<T>): f is HexToBase64Function<T>;
/** @internal */
export type URIEncodeFunction<T extends EastType = EastType> = {
    ast_type: "URIEncode";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isURIEncodeFunction<T extends EastType>(f: EastFunction<T>): f is URIEncodeFunction<T>;
/** @internal */
export type URIDecodeFunction<T extends EastType = EastType> = {
    ast_type: "URIDecode";
    type: T;
    value: EastFunction<StringType>;
};
/** @internal */
export declare function isURIDecodeFunction<T extends EastType>(f: EastFunction<T>): f is URIEncodeFunction<T>;
/** @internal */
export type NewSetFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "NewSet";
    values: EastFunction<StringType>[];
};
/** @internal */
export declare function isNewSetFunction<T extends EastType>(f: EastFunction<T>): f is NewSetFunction<T>;
/** @internal */
export type ToSetFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "ToSet";
    collection: EastFunction<SetType | DictType | ArrayType>;
    input_value?: Variable | undefined;
    input_key?: Variable | undefined;
    output_value: EastFunction<StringType>;
};
/** @internal */
export declare function isToSetFunction<T extends EastType>(f: EastFunction<T>): f is ToSetFunction<T>;
/** @internal */
export type InFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "In";
    collection: EastFunction<SetType | DictType | ArrayType>;
    key: EastFunction;
};
/** @internal */
export declare function isInFunction<T extends EastType>(f: EastFunction<T>): f is InFunction<T>;
/** @internal */
export type SubsetEqualFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "SubsetEqual";
    first: EastFunction<SetType>;
    second: EastFunction<SetType>;
};
/** @internal */
export declare function isSubsetEqualFunction<T extends EastType>(f: EastFunction<T>): f is SubsetEqualFunction<T>;
/** @internal */
export type UnionFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Union";
    first: EastFunction<SetType>;
    second: EastFunction<SetType>;
};
/** @internal */
export declare function isUnionFunction<T extends EastType>(f: EastFunction<T>): f is UnionFunction<T>;
/** @internal */
export type IntersectFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Intersect";
    first: EastFunction<SetType>;
    second: EastFunction<SetType>;
};
/** @internal */
export declare function isIntersectFunction<T extends EastType>(f: EastFunction<T>): f is IntersectFunction<T>;
/** @internal */
export type SetDiffFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "SetDiff";
    first: EastFunction<SetType>;
    second: EastFunction<SetType>;
};
/** @internal */
export declare function isSetDiffFunction<T extends EastType>(f: EastFunction<T>): f is SetDiffFunction<T>;
/** @internal */
export type SymDiffFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "SymDiff";
    first: EastFunction<SetType>;
    second: EastFunction<SetType>;
};
/** @internal */
export declare function isSymDiffFunction<T extends EastType>(f: EastFunction<T>): f is SymDiffFunction<T>;
/** @internal */
export type NewDictFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "NewDict";
    keys: EastFunction<StringType>[];
    values: EastFunction[];
};
/** @internal */
export declare function isNewDictFunction<T extends EastType>(f: EastFunction<T>): f is NewDictFunction<T>;
/** @internal */
export type KeysFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Keys";
    dict: EastFunction<DictType>;
};
/** @internal */
export declare function isKeysFunction<T extends EastType>(f: EastFunction<T>): f is KeysFunction<T>;
/** @internal */
export type ToDictFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "ToDict";
    collection: EastFunction<SetType | DictType | ArrayType>;
    input_value?: Variable | undefined;
    input_key?: Variable | undefined;
    output_value: EastFunction;
    output_key: EastFunction<StringType>;
    previous_value?: Variable | undefined;
    initial_value?: EastFunction | undefined;
};
/** @internal */
export declare function isToDictFunction<T extends EastType>(f: EastFunction<T>): f is ToDictFunction<T>;
/** @internal */
export type NewArrayFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "NewArray";
    values: EastFunction[];
};
/** @internal */
export declare function isNewArrayFunction<T extends EastType>(f: EastFunction<T>): f is NewArrayFunction<T>;
/** @internal */
export type ToArrayFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "ToArray";
    collection: EastFunction<SetType | DictType | ArrayType>;
    input_value?: Variable | undefined;
    input_key?: Variable | undefined;
    output_value: EastFunction;
};
/** @internal */
export declare function isToArrayFunction<T extends EastType>(f: EastFunction<T>): f is ToArrayFunction<T>;
/** @internal */
export type RangeFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Range";
    start: EastFunction<IntegerType>;
    stop: EastFunction<IntegerType>;
};
/** @internal */
export declare function isRangeFunction<T extends EastType>(f: EastFunction<T>): f is RangeFunction<T>;
/** @internal */
export type GetFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Get";
    dict: EastFunction;
    key: EastFunction;
    default: EastFunction | null;
};
/** @internal */
export declare function isGetFunction<T extends EastType>(f: EastFunction<T>): f is GetFunction<T>;
/** @internal */
export type OnlyKeyFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "OnlyKey";
    dict: EastFunction<DictType>;
};
/** @internal */
export declare function isOnlyKeyFunction<T extends EastType>(f: EastFunction<T>): f is OnlyKeyFunction<T>;
/** @internal */
export type InsertFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Insert";
    collection: EastFunction<U>;
    key: EastFunction | "first" | "last";
    value?: EastFunction | undefined;
};
/** @internal */
export declare function isInsertFunction<T extends EastType>(f: EastFunction<T>): f is InsertFunction<T>;
/** @internal */
export type UpdateFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Update";
    collection: EastFunction<U>;
    key: EastFunction;
    value: EastFunction;
};
/** @internal */
export declare function isUpdateFunction<T extends EastType>(f: EastFunction<T>): f is UpdateFunction<T>;
/** @internal */
export type DeleteFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Delete";
    collection: EastFunction<U>;
    key: EastFunction | "first" | "last";
};
/** @internal */
export declare function isDeleteFunction<T extends EastType>(f: EastFunction<T>): f is DeleteFunction<T>;
/** @internal */
export type SizeFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Size";
    collection: EastFunction<SetType | DictType | ArrayType | BlobType | StringType>;
};
/** @internal */
export declare function isSizeFunction<T extends EastType>(f: EastFunction<T>): f is SizeFunction<T>;
/** @internal */
export type FilterFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Filter";
    collection: EastFunction<U>;
    predicate: EastFunction<BooleanType>;
    value?: Variable | undefined;
    key?: Variable | undefined;
};
/** @internal */
export declare function isFilterFunction<T extends EastType>(f: EastFunction<T>): f is FilterFunction<T>;
/** @internal */
export type MapValuesFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "MapDict";
    collection: EastFunction;
    "function": EastFunction;
    value?: Variable | undefined;
    key?: Variable | undefined;
};
/** @internal */
export declare function isMapValuesFunction<T extends EastType>(f: EastFunction<T>): f is MapValuesFunction<T>;
/** @internal */
export type FilterMapFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "FilterMap";
    collection: EastFunction;
    "function": EastFunction<VariantType<{
        none: NullType;
        some: EastType;
    }>>;
    value?: Variable | undefined;
    key: Variable;
};
/** @internal */
export declare function isFilterMapFunction<T extends EastType>(f: EastFunction<T>): f is FilterMapFunction<T>;
/** @internal */
export type ReduceFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Reduce";
    collection: EastFunction;
    reducer: EastFunction<U>;
    initial: EastFunction;
    previous: Variable;
    value?: Variable | undefined;
    key?: Variable | undefined;
};
/** @internal */
export declare function isReduceFunction<T extends EastType>(f: EastFunction<T>): f is ReduceFunction<T>;
/** @internal */
export type SortFunction<U extends EastType = EastType> = {
    type: U;
    ast_type: "Sort";
    collection: EastFunction<ArrayType>;
    isless: EastFunction<BooleanType>;
    first: Variable;
    second: Variable;
};
/** @internal */
export declare function isSortFunction<T extends EastType>(f: EastFunction<T>): f is SortFunction<T>;
/** @internal */
export type FieldTypesOf<T> = T extends {
    type: "Struct";
    value: Record<string, EastType>;
} ? T["value"] : never;
/** @internal */
export type FieldFunctionTypesOf<T> = T extends {
    type: "Struct";
    value: Record<string, EastType>;
} ? {
    [K in keyof T["value"]]: EastFunction<T["value"][K]>;
} : never;
/** @internal */
export type FieldTypeOf<T extends {
    type: "Struct";
    value: Record<string, EastType>;
}, K extends keyof T["value"]> = T["value"][K];
/** @internal */
export type StructFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Struct";
    fields: FieldFunctionTypesOf<T>;
};
/** @internal */
export declare function isStructFunction<T extends EastType>(f: EastFunction<T>): f is StructFunction<T>;
/** @internal */
export type GetFieldFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "GetField";
    struct: EastFunction<StructType>;
    key: string;
};
/** @internal */
export declare function isGetFieldFunction<T extends EastType>(f: EastFunction<T>): f is GetFieldFunction<T>;
/** @internal */
export type VariantFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Variant";
    tag: string;
    value: EastFunction;
};
/** @internal */
export declare function isNewVariantFunction<T extends EastType>(f: EastFunction<T>): f is VariantFunction<T>;
/** @internal */
export type MatchFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Match";
    input: EastFunction<VariantType>;
    functions: Record<string, EastFunction>;
    value: string;
};
/** @internal */
export declare function isMatchFunction<T extends EastType>(f: EastFunction<T>): f is MatchFunction<T>;
/** @internal */
export type Utf8EncodeFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Utf8Encode";
    from: EastFunction<StringType>;
};
/** @internal */
export declare function isUtf8EncodeFunction<T extends EastType>(f: EastFunction<T>): f is Utf8EncodeFunction<T>;
/** @internal */
export type Utf8DecodeFunction<T extends EastType = EastType> = {
    type: T;
    ast_type: "Utf8Decode";
    from: EastFunction<BlobType>;
};
/** @internal */
export declare function isUtf8DecodeFunction<T extends EastType>(f: EastFunction<T>): f is Utf8DecodeFunction<T>;