import type { Macro } from "../macro/index.js";
import type { Span } from "../span/index.js";
type ExpMeta = {
    span?: Span;
};
/**

   # Exp

   `Exp` is very close to the concrete syntax,
   this is unlike `Core`, which is elaborated
   and aiming to have a small "core".

   For example, function with multiple arguments
   is implemented in `Exp` and elaborated to `Core`
   which does not support multiple arguments.

**/
export type Exp = Var | Pi | PiImplicit | PiUnfolded | Ap | ApImplicit | ApUnfolded | Fn | FnAnnotated | FnImplicit | FnImplicitAnnotated | FnUnfolded | FnUnfoldedWithRetType | Sigma | SigmaUnfolded | Cons | Quote | Clazz | ClazzUnfolded | Objekt | ObjektUnfolded | New | NewUnfolded | NewAp | Dot | Sequence | SequenceUnfolded | MacroEmbedded;
export type Var = {
    "@type": "Exp";
    "@kind": "Var";
    name: string;
} & ExpMeta;
export declare function Var(name: string, span?: Span): Var;
export type Pi = {
    "@type": "Exp";
    "@kind": "Pi";
    name: string;
    argType: Exp;
    retType: Exp;
} & ExpMeta;
export declare function Pi(name: string, argType: Exp, retType: Exp, span?: Span): Pi;
export type PiImplicit = {
    "@type": "Exp";
    "@kind": "PiImplicit";
    name: string;
    argType: Exp;
    retType: Exp;
} & ExpMeta;
export declare function PiImplicit(name: string, argType: Exp, retType: Exp, span?: Span): PiImplicit;
export type PiUnfolded = {
    "@type": "Exp";
    "@kind": "PiUnfolded";
    bindings: Array<PiBinding>;
    retType: Exp;
} & ExpMeta;
export declare function PiUnfolded(bindings: Array<PiBinding>, retType: Exp, span?: Span): PiUnfolded;
export type PiBinding = PiBindingNameless | PiBindingNamed | PiBindingImplicit;
export type PiBindingNameless = {
    "@kind": "PiBindingNameless";
    type: Exp;
} & ExpMeta;
export declare function PiBindingNameless(type: Exp, span?: Span): PiBindingNameless;
export type PiBindingNamed = {
    "@kind": "PiBindingNamed";
    name: string;
    type: Exp;
} & ExpMeta;
export declare function PiBindingNamed(name: string, type: Exp, span?: Span): PiBindingNamed;
export type PiBindingImplicit = {
    "@kind": "PiBindingImplicit";
    name: string;
    type: Exp;
} & ExpMeta;
export declare function PiBindingImplicit(name: string, type: Exp, span?: Span): PiBindingImplicit;
export type Fn = {
    "@type": "Exp";
    "@kind": "Fn";
    name: string;
    ret: Exp;
} & ExpMeta;
export declare function Fn(name: string, ret: Exp, span?: Span): Fn;
export type FnAnnotated = {
    "@type": "Exp";
    "@kind": "FnAnnotated";
    name: string;
    argType: Exp;
    ret: Exp;
} & ExpMeta;
export declare function FnAnnotated(name: string, argType: Exp, ret: Exp, span?: Span): FnAnnotated;
export type FnImplicit = {
    "@type": "Exp";
    "@kind": "FnImplicit";
    name: string;
    ret: Exp;
} & ExpMeta;
export declare function FnImplicit(name: string, ret: Exp, span?: Span): FnImplicit;
export type FnImplicitAnnotated = {
    "@type": "Exp";
    "@kind": "FnImplicitAnnotated";
    name: string;
    argType: Exp;
    ret: Exp;
} & ExpMeta;
export declare function FnImplicitAnnotated(name: string, argType: Exp, ret: Exp, span?: Span): FnImplicitAnnotated;
export type FnUnfolded = {
    "@type": "Exp";
    "@kind": "FnUnfolded";
    bindings: Array<FnBinding>;
    ret: Exp;
} & ExpMeta;
export declare function FnUnfolded(bindings: Array<FnBinding>, ret: Exp, span?: Span): FnUnfolded;
export type FnUnfoldedWithRetType = {
    "@type": "Exp";
    "@kind": "FnUnfoldedWithRetType";
    bindings: Array<FnBinding>;
    retType: Exp;
    ret: Exp;
} & ExpMeta;
export declare function FnUnfoldedWithRetType(bindings: Array<FnBinding>, retType: Exp, ret: Exp, span?: Span): FnUnfoldedWithRetType;
export type FnBinding = FnBindingName | FnBindingAnnotated | FnBindingImplicit | FnBindingAnnotatedImplicit;
export type FnBindingName = {
    "@kind": "FnBindingName";
    name: string;
} & ExpMeta;
export declare function FnBindingName(name: string, span?: Span): FnBindingName;
export type FnBindingAnnotated = {
    "@kind": "FnBindingAnnotated";
    name: string;
    type: Exp;
} & ExpMeta;
export declare function FnBindingAnnotated(name: string, type: Exp, span?: Span): FnBindingAnnotated;
export type FnBindingImplicit = {
    "@kind": "FnBindingImplicit";
    name: string;
} & ExpMeta;
export declare function FnBindingImplicit(name: string, span?: Span): FnBindingImplicit;
export type FnBindingAnnotatedImplicit = {
    "@kind": "FnBindingAnnotatedImplicit";
    name: string;
    type: Exp;
} & ExpMeta;
export declare function FnBindingAnnotatedImplicit(name: string, type: Exp, span?: Span): FnBindingAnnotatedImplicit;
export type Ap = {
    "@type": "Exp";
    "@kind": "Ap";
    target: Exp;
    arg: Exp;
} & ExpMeta;
export declare function Ap(target: Exp, arg: Exp, span?: Span): Ap;
export type ApImplicit = {
    "@type": "Exp";
    "@kind": "ApImplicit";
    target: Exp;
    arg: Exp;
} & ExpMeta;
export declare function ApImplicit(target: Exp, arg: Exp, span?: Span): ApImplicit;
export type ApUnfolded = {
    "@type": "Exp";
    "@kind": "ApUnfolded";
    target: Exp;
    args: Array<Arg>;
} & ExpMeta;
export declare function ApUnfolded(target: Exp, args: Array<Arg>, span?: Span): ApUnfolded;
export type Arg = ArgPlain | ArgImplicit;
export type ArgPlain = {
    "@kind": "ArgPlain";
    exp: Exp;
};
export declare function ArgPlain(exp: Exp): ArgPlain;
export type ArgImplicit = {
    "@kind": "ArgImplicit";
    exp: Exp;
};
export declare function ArgImplicit(exp: Exp): ArgImplicit;
export type Sigma = {
    "@type": "Exp";
    "@kind": "Sigma";
    name: string;
    carType: Exp;
    cdrType: Exp;
} & ExpMeta;
export declare function Sigma(name: string, carType: Exp, cdrType: Exp, span?: Span): Sigma;
export type SigmaUnfolded = {
    "@type": "Exp";
    "@kind": "SigmaUnfolded";
    bindings: Array<SigmaBinding>;
    cdrType: Exp;
} & ExpMeta;
export declare function SigmaUnfolded(bindings: Array<SigmaBinding>, cdrType: Exp, span?: Span): SigmaUnfolded;
export type SigmaBinding = SigmaBindingNameless | SigmaBindingNamed;
export type SigmaBindingNameless = {
    "@kind": "SigmaBindingNameless";
    type: Exp;
} & ExpMeta;
export declare function SigmaBindingNameless(type: Exp, span?: Span): SigmaBindingNameless;
export type SigmaBindingNamed = {
    "@kind": "SigmaBindingNamed";
    name: string;
    type: Exp;
} & ExpMeta;
export declare function SigmaBindingNamed(name: string, type: Exp, span?: Span): SigmaBindingNamed;
export type Cons = {
    "@type": "Exp";
    "@kind": "Cons";
    car: Exp;
    cdr: Exp;
} & ExpMeta;
export declare function Cons(car: Exp, cdr: Exp, span?: Span): Cons;
export type Quote = {
    "@type": "Exp";
    "@kind": "Quote";
    data: string;
} & ExpMeta;
export declare function Quote(data: string, span?: Span): Quote;
export type Clazz = ClazzNull | ClazzCons | ClazzFulfilled;
export type ClazzNull = {
    "@type": "Exp";
    "@kind": "ClazzNull";
    name?: string;
} & ExpMeta;
export declare function ClazzNull(name?: string, span?: Span): ClazzNull;
export type ClazzCons = {
    "@type": "Exp";
    "@kind": "ClazzCons";
    propertyName: string;
    localName: string;
    propertyType: Exp;
    rest: Clazz;
    name?: string;
} & ExpMeta;
export declare function ClazzCons(propertyName: string, localName: string, propertyType: Exp, rest: Clazz, name?: string, span?: Span): ClazzCons;
export type ClazzFulfilled = {
    "@type": "Exp";
    "@kind": "ClazzFulfilled";
    propertyName: string;
    localName: string;
    propertyType: Exp;
    property: Exp;
    rest: Clazz;
    name?: string;
} & ExpMeta;
export declare function ClazzFulfilled(propertyName: string, localName: string, propertyType: Exp, property: Exp, rest: Clazz, name?: string, span?: Span): ClazzFulfilled;
export type ClazzUnfolded = {
    "@type": "Exp";
    "@kind": "ClazzUnfolded";
    bindings: Array<ClazzBinding>;
    name?: string;
} & ExpMeta;
export declare function ClazzUnfolded(bindings: Array<ClazzBinding>, name?: string, span?: Span): ClazzUnfolded;
export type ClazzBinding = ClazzBindingAbstract | ClazzBindingFulfilled;
export type ClazzBindingAbstract = {
    "@kind": "ClazzBindingAbstract";
    name: string;
    propertyType: Exp;
};
export declare function ClazzBindingAbstract(name: string, propertyType: Exp): ClazzBindingAbstract;
export type ClazzBindingFulfilled = {
    "@kind": "ClazzBindingFulfilled";
    name: string;
    propertyType: Exp;
    property: Exp;
};
export declare function ClazzBindingFulfilled(name: string, propertyType: Exp, property: Exp): ClazzBindingFulfilled;
export type Objekt = {
    "@type": "Exp";
    "@kind": "Objekt";
    properties: Record<string, Exp>;
} & ExpMeta;
export declare function Objekt(properties: Record<string, Exp>, span?: Span): Objekt;
export type ObjektUnfolded = {
    "@type": "Exp";
    "@kind": "ObjektUnfolded";
    properties: Array<Property>;
} & ExpMeta;
export declare function ObjektUnfolded(properties: Array<Property>, span?: Span): ObjektUnfolded;
export type Property = PropertyPlain | PropertySpread;
export type PropertyPlain = {
    "@kind": "PropertyPlain";
    name: string;
    exp: Exp;
};
export declare function PropertyPlain(name: string, exp: Exp): PropertyPlain;
export type PropertySpread = {
    "@kind": "PropertySpread";
    exp: Exp;
};
export declare function PropertySpread(exp: Exp): PropertySpread;
export type New = {
    "@type": "Exp";
    "@kind": "New";
    name: string;
    properties: Record<string, Exp>;
} & ExpMeta;
export declare function New(name: string, properties: Record<string, Exp>, span?: Span): New;
export type NewUnfolded = {
    "@type": "Exp";
    "@kind": "NewUnfolded";
    name: string;
    properties: Array<Property>;
} & ExpMeta;
export declare function NewUnfolded(name: string, properties: Array<Property>, span?: Span): NewUnfolded;
export type NewAp = {
    "@type": "Exp";
    "@kind": "NewAp";
    name: string;
    args: Array<Arg>;
} & ExpMeta;
export declare function NewAp(name: string, args: Array<Arg>, span?: Span): NewAp;
export type Dot = {
    "@type": "Exp";
    "@kind": "Dot";
    target: Exp;
    name: string;
} & ExpMeta;
export declare function Dot(target: Exp, name: string, span?: Span): Dot;
export type Sequence = SequenceLet | SequenceLetThe | SequenceCheck;
export type SequenceLet = {
    "@type": "Exp";
    "@kind": "SequenceLet";
    name: string;
    exp: Exp;
    ret: Exp;
} & ExpMeta;
export declare function SequenceLet(name: string, exp: Exp, ret: Exp, span?: Span): SequenceLet;
export type SequenceLetThe = {
    "@type": "Exp";
    "@kind": "SequenceLetThe";
    name: string;
    type: Exp;
    exp: Exp;
    ret: Exp;
} & ExpMeta;
export declare function SequenceLetThe(name: string, type: Exp, exp: Exp, ret: Exp, span?: Span): SequenceLetThe;
export type SequenceCheck = {
    "@type": "Exp";
    "@kind": "SequenceCheck";
    exp: Exp;
    type: Exp;
    ret: Exp;
} & ExpMeta;
export declare function SequenceCheck(exp: Exp, type: Exp, ret: Exp, span?: Span): SequenceCheck;
export type SequenceUnfolded = {
    "@type": "Exp";
    "@kind": "SequenceUnfolded";
    bindings: Array<SequenceBinding>;
    ret: Exp;
} & ExpMeta;
export declare function SequenceUnfolded(bindings: Array<SequenceBinding>, ret: Exp, span?: Span): SequenceUnfolded;
export type SequenceBinding = SequenceBindingLet | SequenceBindingLetThe | SequenceBindingCheck;
export type SequenceBindingLet = {
    "@kind": "SequenceBindingLet";
    name: string;
    exp: Exp;
} & ExpMeta;
export declare function SequenceBindingLet(name: string, exp: Exp, span?: Span): SequenceBindingLet;
export type SequenceBindingLetThe = {
    "@kind": "SequenceBindingLetThe";
    name: string;
    type: Exp;
    exp: Exp;
} & ExpMeta;
export declare function SequenceBindingLetThe(name: string, type: Exp, exp: Exp, span?: Span): SequenceBindingLetThe;
export type SequenceBindingCheck = {
    "@kind": "SequenceBindingCheck";
    exp: Exp;
    type: Exp;
} & ExpMeta;
export declare function SequenceBindingCheck(exp: Exp, type: Exp, span?: Span): SequenceBindingCheck;
export type MacroEmbedded = {
    "@type": "Exp";
    "@kind": "MacroEmbedded";
    macro: Macro;
} & ExpMeta;
export declare function MacroEmbedded(macro: Macro, span?: Span): MacroEmbedded;
export {};
//# sourceMappingURL=Exp.d.ts.map