import { MergeTypes } from '../../utils/types';
import { EastFunction, VariantFunction, Variable } from '../functions';
import { EastType, EastTypeOf, NullType, PrimitiveValue, Value, ValueTypeOf, VariantType } from '../types';
/**
* Return an {@link EastFunction} that constructs a variant with a given case (or tag) and associated value.
*
* @param case A string tag identifying which case the constructed variant is
* @param value An optional {@link EastFunction} to create the data assocated with this variant (default `null`)
*
* @category Expression
* @see {@link Match}
*
* @example
* ```typescript
* // ...
* // Calculate the average price from an array of historical prices, `priceHistory`.
* // An Option variant is returned - the none case for when the array is empty, and otherwise the some case wraps the mean.
* AveragePrice: IfElse(
*     Greater(Size(priceHistory), 0n),
*     Variant("some", Divide(
*         AddAll(priceHistory),
*         Size(priceHistory)
*     )),
*     Variant("none"),
* )
* // ...
* ```
*/
export declare function Variant<Tag extends string>(tag: Tag): VariantFunction<VariantType<{
    [K in Tag]: NullType;
}>>;
export declare function Variant<Tag extends string, T extends EastType>(tag: Tag, data: EastFunction<T>): VariantFunction<VariantType<{
    [K in Tag]: T;
}>>;
export declare function Variant<Tag extends string, T extends Value>(tag: Tag, data: T): VariantFunction<VariantType<{
    [K in Tag]: EastTypeOf<T>;
}>>;
export declare function Variant<V extends VariantType, Tag extends keyof V["value"], D extends EastFunction>(tag: Tag, data: D & (D["type"] & V["value"][Tag] extends never ? never : unknown), type: V): VariantFunction<V>;
export declare function Variant<V extends VariantType, Tag extends keyof V["value"], D extends PrimitiveValue>(tag: Tag, data: D & (ValueTypeOf<D> & V["value"][Tag] extends never ? never : unknown), type: V): VariantFunction<V>;
/**
 * Match an expression depending on the cases (or tags) of an input variant.
 * This is the primary method to access a variant's case (or tag) and any associated data.
 *
 * @param input the {@link EastFunction} for the input variant
 * @param functions a function returning an {@link EastFunction} for each possible case or tag of the input variant
 * @param defaultValue an optional {@link EastFunction} for any possible case or tag not listed in `functions`
 *
 * @category Expression
 * @see {@link Variant}
 *
 * @example
 * ```typescript
 * // ...
 * // Get the name of the product from the product data, or else return the string "####"
 * ProductName: Match(
 *     Variable("ProductName", VariantType({ some: StringType, none: NullType })),
 *     {
 *         some: name => name
 *         none: _ => "####"
 *     },
 * )
 * // ...
 * ```
 */
export declare function Match<Variants extends Record<string, EastType>, Fs extends {
    [K in keyof Variants]: ((v: Variable<Variants[K]>) => EastFunction);
}>(input: EastFunction<VariantType<Variants>>, functions: Fs, defaultValue?: EastFunction): MergeTypes<{
    [Tag in keyof Variants]: ReturnType<Fs[Tag]>["type"];
}> extends never ? unknown : {
    ast_type: "Match";
    type: MergeTypes<{
        [Tag in keyof Variants]: ReturnType<Fs[Tag]>["type"];
    }>;
    input: EastFunction<VariantType>;
    functions: Record<string, EastFunction>;
    value: string;
};
export declare function Match<Variants extends Record<string, EastType>, Fs extends {
    [K in keyof Variants]?: ((v: Variable<Variants[K]>) => EastFunction);
}, D extends EastType>(input: EastFunction<VariantType<Variants>>, functions: Fs, defaultValue: EastFunction<D>): (D & MergeTypes<{
    [Tag in keyof Fs]: ReturnType<Exclude<Fs[Tag], undefined>>["type"];
}>) extends never ? unknown : {
    ast_type: "Match";
    type: (D & MergeTypes<{
        [Tag in keyof Fs]: ReturnType<Exclude<Fs[Tag], undefined>>["type"];
    }>);
    input: EastFunction<VariantType>;
    functions: Record<string, EastFunction>;
    value: string;
};