/*!
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
import { CalcObj, CalcValue, Pending, Resolver, Runtime, TypedBinOp, TypedUnaryOp } from "./types";
import { SyntaxKind } from "./parser";
export declare function makeError(message: string): CalcObj<unknown>;
export declare const errors: {
    readonly appOnNonFunction: CalcObj<unknown>;
    readonly div0: CalcObj<unknown>;
    readonly functionArity: CalcObj<unknown>;
    readonly functionAsOpArgument: CalcObj<unknown>;
    readonly nonStringField: CalcObj<unknown>;
    readonly readOnNonObject: CalcObj<unknown>;
    readonly resolveError: CalcObj<unknown>;
    readonly typeError: CalcObj<unknown>;
};
/**
 * We use the following to fake an existential type. We really want to
 * have something like: exists U. TypedBinOp<U>, where the `check`
 * function of the typed op is used produces values of sealed type.
 * Once a value is checked, it can then be passed to the op.
 *
 * We can't do this so we just forge some unique type that at least
 * lets us store all binary operations in a single map.
 */
declare const $skolem: unique symbol;
export declare type Skolem = {
    [$skolem]: unknown;
};
export declare const binOps: {
    readonly 9: TypedBinOp<Skolem>;
    readonly 10: TypedBinOp<Skolem>;
    readonly 7: TypedBinOp<Skolem>;
    readonly 21: TypedBinOp<Skolem>;
    readonly 8: TypedBinOp<Skolem>;
    readonly 16: TypedBinOp<Skolem>;
    readonly 12: TypedBinOp<Skolem>;
    readonly 13: TypedBinOp<Skolem>;
    readonly 14: TypedBinOp<Skolem>;
    readonly 15: TypedBinOp<Skolem>;
    readonly 17: TypedBinOp<Skolem>;
};
export declare const unaryOps: {
    readonly 9: TypedUnaryOp<Skolem>;
    readonly 10: TypedUnaryOp<Skolem>;
};
/**
 *  Default runtime implementation.  This supports applicative tracing
 *  of pending values and will attempt to find all pending
 *  computations before exiting.
 */
declare const $effect: unique symbol;
export declare type Delay = {
    [$effect]: unknown;
};
/**
 * A expression of type `Delayed<T>` represents a computation that
 * either delivers a value of type `T`, or is blocked on multiple
 * requests. A tracer is used to lift a single blocked request
 * (`Pending<T>`) into the `Delayed` effect.
 */
export declare type Delayed<T> = T | Delay;
export declare function isDelayed<T>(x: T | Delay): x is Delay;
/**
 * A `Trace` function lifts possibly pending values into `Delayed` and
 * records any pending value. This allows us to gather multiple
 * pending values in a single computation
 */
export declare type Trace = <T>(value: T | Pending<T>) => Delayed<T>;
export declare function makeTracer(): [Pending<unknown>[], Trace];
/**
 * Core Tracing Runtime
 *
 * Returns evaluated calc values or the sentinel `Delay` value.
 * To find the actual `Pending` values see the results of `trace`.
 */
export declare class CoreRuntime implements Runtime<Delay> {
    readonly trace: Trace;
    constructor(trace: Trace);
    isDelayed: typeof isDelayed;
    read<C, F>(context: C, receiver: Delayed<CalcValue<C>>, prop: string, fallback: F): Delayed<CalcValue<C> | F>;
    ifS<R>(cond: Delayed<boolean>, cont: (cond: boolean) => Delayed<R>): Delayed<R>;
    app1<A, C>(context: C, op: TypedUnaryOp<A>, expr: Delayed<CalcValue<C>>): Delayed<CalcValue<C>>;
    app2<A, C>(context: C, op: TypedBinOp<A>, l: Delayed<CalcValue<C>>, r: Delayed<CalcValue<C>>): Delayed<CalcValue<C>>;
    appN<C, F>(context: C, fn: Delayed<CalcValue<C>>, args: Delayed<CalcValue<C>>[], fallback: F): Delayed<CalcValue<C> | F>;
}
export declare function createObjectResolver<C>(root: CalcObj<C>, trace: Trace): Resolver<C, string, Delay>;
/**
 * Exports the basic building blocks of a formula runtime.
 * - Error values
 * - Operator implementations.
 * - An effect-handling runtime.
 */
export declare type Errors = typeof errors;
export declare type BinaryOps = typeof binOps;
export declare type UnaryOps = typeof unaryOps;
export {};
//# sourceMappingURL=core.d.ts.map