import { Infer, Type } from 'cito';
import { Selection } from './Selection.js';
import { TargetData } from './TargetData.js';
export declare enum UnaryOp {
    Not = "Not",
    IsNull = "IsNull"
}
export declare enum BinaryOp {
    Add = "Add",
    Subt = "Subt",
    Mult = "Mult",
    Mod = "Mod",
    Div = "Div",
    Greater = "Greater",
    GreaterOrEqual = "GreaterOrEqual",
    Less = "Less",
    LessOrEqual = "LessOrEqual",
    Equals = "Equals",
    NotEquals = "NotEquals",
    And = "And",
    Or = "Or",
    Like = "Like",
    In = "In",
    NotIn = "NotIn",
    Concat = "Concat"
}
export type ExprData = ExprData.UnOp | ExprData.BinOp | ExprData.Field | ExprData.Access | ExprData.Value | ExprData.Record | ExprData.Case;
export declare namespace ExprData {
    namespace types {
        class UnOp {
            type: Type<"unop">;
            op: Type<UnaryOp>;
            expr: Type<ExprData>;
        }
        class BinOp {
            type: Type<"binop">;
            a: Type<ExprData>;
            op: Type<BinaryOp>;
            b: Type<ExprData>;
        }
        class Field {
            type: Type<"field">;
            target: Type<{
                name?: string | undefined;
                type?: import("../Type.js").TypeTarget | undefined;
            }>;
            field: Type<string>;
        }
        class Access {
            type: Type<"access">;
            expr: Type<ExprData>;
            field: Type<string>;
        }
        class Value {
            type: Type<"value">;
            value: Type<any>;
        }
        class Record {
            type: Type<"record">;
            fields: Type<globalThis.Record<string, ExprData>>;
        }
        class Case {
            type: Type<"case">;
            expr: Type<ExprData>;
            cases: Type<[ExprData, Selection<T>][]>;
            defaultCase?: Type<Selection<T> | undefined> | undefined;
        }
    }
    export interface UnOp extends Infer<types.UnOp> {
    }
    export function UnOp(op: UnaryOp, expr: ExprData): ExprData;
    export interface BinOp extends Infer<types.BinOp> {
    }
    export function BinOp(a: ExprData, op: BinaryOp, b: ExprData): ExprData;
    export interface Field extends Infer<types.Field> {
    }
    export function Field(target: TargetData, field: string): ExprData;
    export interface Access extends Infer<types.Access> {
    }
    export function Access(expr: ExprData, field: string): ExprData;
    export interface Value extends Infer<types.Value> {
    }
    export function Value(value: any): ExprData;
    export interface Record extends Infer<types.Record> {
    }
    export function Record(fields: {
        [k: string]: ExprData;
    }): ExprData;
    export interface Case extends Infer<types.Case> {
    }
    export function Case(expr: ExprData, cases: Array<[ExprData, Selection]>, defaultCase?: Selection): ExprData;
    export const adt: Type<ExprData>;
    export {};
}