import * as Ohm from "ohm-js";
declare const inspect: unique symbol;
declare type Result<A> = {
    ok: true;
    value: A;
} | {
    ok: false;
    error: string;
};
export declare abstract class Node {
}
export declare class Meta {
    readonly interval: Ohm.Interval;
    constructor(interval: Ohm.Interval);
    static has_instance(x: any): boolean;
    get position(): {
        line: any;
        column: any;
    };
    get range(): {
        start: number;
        end: number;
    };
    get source_slice(): string;
    get formatted_position_message(): string;
    [inspect](): {
        line: any;
        column: any;
    };
}
export declare class Program extends Node {
    readonly pos: Meta;
    readonly declarations: Declaration[];
    readonly tag: "Program";
    constructor(pos: Meta, declarations: Declaration[]);
    static has_instance(x: any): boolean;
}
export declare class Metadata extends Node {
    readonly doc: string[];
    readonly tag: "Metadata";
    constructor(doc: string[]);
    static has_instance(x: any): boolean;
}
declare type $p_Declaration<$T> = {
    ForeignType(pos: Meta, cmeta: Metadata, name: Name, target: Namespace): $T;
    Relation(pos: Meta, cmeta: Metadata, signature: Signature<RelationPart>): $T;
    Do(pos: Meta, body: Statement[]): $T;
    Command(pos: Meta, cmeta: Metadata, signature: Signature<Parameter>, contract: Contract, body: Statement[], ttest: (TrailingTest | null)): $T;
    Define(pos: Meta, cmeta: Metadata, name: Name, value: Expression): $T;
    AbstractType(pos: Meta, cmeta: Metadata, typ: TypeDef): $T;
    EnumType(pos: Meta, cmeta: Metadata, name: Name, variants: Name[]): $T;
    SingletonType(pos: Meta, cmeta: Metadata, typ: TypeDef, init: TypeInit[]): $T;
    Type(pos: Meta, cmeta: Metadata, typ: TypeDef, fields: TypeField[]): $T;
    Trait(pos: Meta, cmeta: Metadata, name: Name): $T;
    ImplementTrait(pos: Meta, typ: TypeApp, trait: Trait): $T;
    Action(pos: Meta, cmeta: Metadata, self: Parameter, name: Name, title: (Expression | null), pred: Predicate, rank: Rank, body: Statement[], commands: TypeInit[]): $T;
    When(pos: Meta, cmeta: Metadata, pred: Predicate, body: Statement[]): $T;
    Context(pos: Meta, cmeta: Metadata, name: Name, items: Declaration[]): $T;
    Open(pos: Meta, ns: Namespace): $T;
    Local(pos: Meta, decl: Declaration): $T;
    Test(pos: Meta, title: String, body: Statement[]): $T;
    Effect(pos: Meta, cmeta: Metadata, name: Name, cases: EffectCase[]): $T;
    Capability(pos: Meta, cmeta: Metadata, name: Name): $T;
    Protect(pos: Meta, capability: Name, entity: ProtectEntity): $T;
};
export declare abstract class Declaration extends Node {
    abstract tag: "ForeignType" | "Relation" | "Do" | "Command" | "Define" | "AbstractType" | "EnumType" | "SingletonType" | "Type" | "Trait" | "ImplementTrait" | "Action" | "When" | "Context" | "Open" | "Local" | "Test" | "Effect" | "Capability" | "Protect";
    abstract match<$T>(p: $p_Declaration<$T>): $T;
    static get ForeignType(): typeof $$Declaration$_ForeignType;
    static get Relation(): typeof $$Declaration$_Relation;
    static get Do(): typeof $$Declaration$_Do;
    static get Command(): typeof $$Declaration$_Command;
    static get Define(): typeof $$Declaration$_Define;
    static get AbstractType(): typeof $$Declaration$_AbstractType;
    static get EnumType(): typeof $$Declaration$_EnumType;
    static get SingletonType(): typeof $$Declaration$_SingletonType;
    static get Type(): typeof $$Declaration$_Type;
    static get Trait(): typeof $$Declaration$_Trait;
    static get ImplementTrait(): typeof $$Declaration$_ImplementTrait;
    static get Action(): typeof $$Declaration$_Action;
    static get When(): typeof $$Declaration$_When;
    static get Context(): typeof $$Declaration$_Context;
    static get Open(): typeof $$Declaration$_Open;
    static get Local(): typeof $$Declaration$_Local;
    static get Test(): typeof $$Declaration$_Test;
    static get Effect(): typeof $$Declaration$_Effect;
    static get Capability(): typeof $$Declaration$_Capability;
    static get Protect(): typeof $$Declaration$_Protect;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_ForeignType extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly target: Namespace;
    readonly tag: "ForeignType";
    constructor(pos: Meta, cmeta: Metadata, name: Name, target: Namespace);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Relation extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly signature: Signature<RelationPart>;
    readonly tag: "Relation";
    constructor(pos: Meta, cmeta: Metadata, signature: Signature<RelationPart>);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Do extends Declaration {
    readonly pos: Meta;
    readonly body: Statement[];
    readonly tag: "Do";
    constructor(pos: Meta, body: Statement[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Command extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly signature: Signature<Parameter>;
    readonly contract: Contract;
    readonly body: Statement[];
    readonly ttest: (TrailingTest | null);
    readonly tag: "Command";
    constructor(pos: Meta, cmeta: Metadata, signature: Signature<Parameter>, contract: Contract, body: Statement[], ttest: (TrailingTest | null));
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Define extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly value: Expression;
    readonly tag: "Define";
    constructor(pos: Meta, cmeta: Metadata, name: Name, value: Expression);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_AbstractType extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly typ: TypeDef;
    readonly tag: "AbstractType";
    constructor(pos: Meta, cmeta: Metadata, typ: TypeDef);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_EnumType extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly variants: Name[];
    readonly tag: "EnumType";
    constructor(pos: Meta, cmeta: Metadata, name: Name, variants: Name[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_SingletonType extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly typ: TypeDef;
    readonly init: TypeInit[];
    readonly tag: "SingletonType";
    constructor(pos: Meta, cmeta: Metadata, typ: TypeDef, init: TypeInit[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Type extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly typ: TypeDef;
    readonly fields: TypeField[];
    readonly tag: "Type";
    constructor(pos: Meta, cmeta: Metadata, typ: TypeDef, fields: TypeField[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Trait extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly tag: "Trait";
    constructor(pos: Meta, cmeta: Metadata, name: Name);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_ImplementTrait extends Declaration {
    readonly pos: Meta;
    readonly typ: TypeApp;
    readonly trait: Trait;
    readonly tag: "ImplementTrait";
    constructor(pos: Meta, typ: TypeApp, trait: Trait);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Action extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly self: Parameter;
    readonly name: Name;
    readonly title: (Expression | null);
    readonly pred: Predicate;
    readonly rank: Rank;
    readonly body: Statement[];
    readonly commands: TypeInit[];
    readonly tag: "Action";
    constructor(pos: Meta, cmeta: Metadata, self: Parameter, name: Name, title: (Expression | null), pred: Predicate, rank: Rank, body: Statement[], commands: TypeInit[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_When extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly pred: Predicate;
    readonly body: Statement[];
    readonly tag: "When";
    constructor(pos: Meta, cmeta: Metadata, pred: Predicate, body: Statement[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Context extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly items: Declaration[];
    readonly tag: "Context";
    constructor(pos: Meta, cmeta: Metadata, name: Name, items: Declaration[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Open extends Declaration {
    readonly pos: Meta;
    readonly ns: Namespace;
    readonly tag: "Open";
    constructor(pos: Meta, ns: Namespace);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Local extends Declaration {
    readonly pos: Meta;
    readonly decl: Declaration;
    readonly tag: "Local";
    constructor(pos: Meta, decl: Declaration);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Test extends Declaration {
    readonly pos: Meta;
    readonly title: String;
    readonly body: Statement[];
    readonly tag: "Test";
    constructor(pos: Meta, title: String, body: Statement[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Effect extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly cases: EffectCase[];
    readonly tag: "Effect";
    constructor(pos: Meta, cmeta: Metadata, name: Name, cases: EffectCase[]);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Capability extends Declaration {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly tag: "Capability";
    constructor(pos: Meta, cmeta: Metadata, name: Name);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Declaration$_Protect extends Declaration {
    readonly pos: Meta;
    readonly capability: Name;
    readonly entity: ProtectEntity;
    readonly tag: "Protect";
    constructor(pos: Meta, capability: Name, entity: ProtectEntity);
    match<$T>(p: $p_Declaration<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_ProtectEntity<$T> = {
    Type(pos: Meta, name: Name): $T;
    Trait(pos: Meta, name: Name): $T;
    Effect(pos: Meta, name: Name): $T;
    Definition(pos: Meta, name: Name): $T;
};
export declare abstract class ProtectEntity extends Node {
    abstract tag: "Type" | "Trait" | "Effect" | "Definition";
    abstract match<$T>(p: $p_ProtectEntity<$T>): $T;
    static get Type(): typeof $$ProtectEntity$_Type;
    static get Trait(): typeof $$ProtectEntity$_Trait;
    static get Effect(): typeof $$ProtectEntity$_Effect;
    static get Definition(): typeof $$ProtectEntity$_Definition;
    static has_instance(x: any): boolean;
}
export declare class $$ProtectEntity$_Type extends ProtectEntity {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Type";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_ProtectEntity<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ProtectEntity$_Trait extends ProtectEntity {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Trait";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_ProtectEntity<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ProtectEntity$_Effect extends ProtectEntity {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Effect";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_ProtectEntity<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ProtectEntity$_Definition extends ProtectEntity {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Definition";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_ProtectEntity<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class EffectCase extends Node {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly name: Name;
    readonly params: Parameter[];
    readonly tag: "EffectCase";
    constructor(pos: Meta, cmeta: Metadata, name: Name, params: Parameter[]);
    static has_instance(x: any): boolean;
}
export declare class Handler extends Node {
    readonly pos: Meta;
    readonly name: Name;
    readonly variant: Name;
    readonly args: Name[];
    readonly body: Statement[];
    readonly tag: "Handler";
    constructor(pos: Meta, name: Name, variant: Name, args: Name[], body: Statement[]);
    static has_instance(x: any): boolean;
}
export declare class TrailingTest extends Node {
    readonly pos: Meta;
    readonly body: Statement[];
    readonly tag: "TrailingTest";
    constructor(pos: Meta, body: Statement[]);
    static has_instance(x: any): boolean;
}
export declare class Contract extends Node {
    readonly pos: Meta;
    readonly ret: (TypeConstraint | null);
    readonly pre: ContractCondition[];
    readonly post: ContractCondition[];
    readonly tag: "Contract";
    constructor(pos: Meta, ret: (TypeConstraint | null), pre: ContractCondition[], post: ContractCondition[]);
    static has_instance(x: any): boolean;
}
export declare class ContractCondition extends Node {
    readonly pos: Meta;
    readonly name: Name;
    readonly expr: Expression;
    readonly tag: "ContractCondition";
    constructor(pos: Meta, name: Name, expr: Expression);
    static has_instance(x: any): boolean;
}
export declare class TypeDef extends Node {
    readonly parent: (TypeConstraint | null);
    readonly name: Name;
    readonly tag: "TypeDef";
    constructor(parent: (TypeConstraint | null), name: Name);
    static has_instance(x: any): boolean;
}
export declare class FFI extends Node {
    readonly pos: Meta;
    readonly name: Namespace;
    readonly args: Name[];
    readonly tag: "FFI";
    constructor(pos: Meta, name: Namespace, args: Name[]);
    static has_instance(x: any): boolean;
}
export declare class TypeField extends Node {
    readonly pos: Meta;
    readonly visibility: FieldVisibility;
    readonly parameter: Parameter;
    readonly tag: "TypeField";
    constructor(pos: Meta, visibility: FieldVisibility, parameter: Parameter);
    static has_instance(x: any): boolean;
}
declare type $p_FieldVisibility<$T> = {
    Local(): $T;
    Global(): $T;
};
export declare abstract class FieldVisibility extends Node {
    abstract tag: "Local" | "Global";
    abstract match<$T>(p: $p_FieldVisibility<$T>): $T;
    static get Local(): typeof $$FieldVisibility$_Local;
    static get Global(): typeof $$FieldVisibility$_Global;
    static has_instance(x: any): boolean;
}
export declare class $$FieldVisibility$_Local extends FieldVisibility {
    readonly tag: "Local";
    constructor();
    match<$T>(p: $p_FieldVisibility<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$FieldVisibility$_Global extends FieldVisibility {
    readonly tag: "Global";
    constructor();
    match<$T>(p: $p_FieldVisibility<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Rank<$T> = {
    Expr(expr: Expression): $T;
    Unranked(pos: Meta): $T;
};
export declare abstract class Rank extends Node {
    abstract tag: "Expr" | "Unranked";
    abstract match<$T>(p: $p_Rank<$T>): $T;
    static get Expr(): typeof $$Rank$_Expr;
    static get Unranked(): typeof $$Rank$_Unranked;
    static has_instance(x: any): boolean;
}
export declare class $$Rank$_Expr extends Rank {
    readonly expr: Expression;
    readonly tag: "Expr";
    constructor(expr: Expression);
    match<$T>(p: $p_Rank<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Rank$_Unranked extends Rank {
    readonly pos: Meta;
    readonly tag: "Unranked";
    constructor(pos: Meta);
    match<$T>(p: $p_Rank<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_TypeInit<$T> = {
    Fact(pos: Meta, sig: PartialSignature<Expression>): $T;
    Command(pos: Meta, cmeta: Metadata, sig: PartialSignature<Parameter>, contract: Contract, body: Statement[], ttest: (TrailingTest | null)): $T;
};
export declare abstract class TypeInit extends Node {
    abstract tag: "Fact" | "Command";
    abstract match<$T>(p: $p_TypeInit<$T>): $T;
    static get Fact(): typeof $$TypeInit$_Fact;
    static get Command(): typeof $$TypeInit$_Command;
    static has_instance(x: any): boolean;
}
export declare class $$TypeInit$_Fact extends TypeInit {
    readonly pos: Meta;
    readonly sig: PartialSignature<Expression>;
    readonly tag: "Fact";
    constructor(pos: Meta, sig: PartialSignature<Expression>);
    match<$T>(p: $p_TypeInit<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$TypeInit$_Command extends TypeInit {
    readonly pos: Meta;
    readonly cmeta: Metadata;
    readonly sig: PartialSignature<Parameter>;
    readonly contract: Contract;
    readonly body: Statement[];
    readonly ttest: (TrailingTest | null);
    readonly tag: "Command";
    constructor(pos: Meta, cmeta: Metadata, sig: PartialSignature<Parameter>, contract: Contract, body: Statement[], ttest: (TrailingTest | null));
    match<$T>(p: $p_TypeInit<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Parameter<$T> = {
    Untyped(pos: Meta, name: Name): $T;
    Typed(pos: Meta, name: Name, typ: TypeConstraint): $T;
    TypedOnly(pos: Meta, typ: TypeConstraint): $T;
};
export declare abstract class Parameter extends Node {
    abstract tag: "Untyped" | "Typed" | "TypedOnly";
    abstract match<$T>(p: $p_Parameter<$T>): $T;
    static get Untyped(): typeof $$Parameter$_Untyped;
    static get Typed(): typeof $$Parameter$_Typed;
    static get TypedOnly(): typeof $$Parameter$_TypedOnly;
    static has_instance(x: any): boolean;
}
export declare class $$Parameter$_Untyped extends Parameter {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Untyped";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_Parameter<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Parameter$_Typed extends Parameter {
    readonly pos: Meta;
    readonly name: Name;
    readonly typ: TypeConstraint;
    readonly tag: "Typed";
    constructor(pos: Meta, name: Name, typ: TypeConstraint);
    match<$T>(p: $p_Parameter<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Parameter$_TypedOnly extends Parameter {
    readonly pos: Meta;
    readonly typ: TypeConstraint;
    readonly tag: "TypedOnly";
    constructor(pos: Meta, typ: TypeConstraint);
    match<$T>(p: $p_Parameter<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_TypeApp<$T> = {
    Named(pos: Meta, name: Name): $T;
    Static(pos: Meta, typ: TypeApp): $T;
    Function(pos: Meta, args: TypeConstraint[], ret: TypeConstraint): $T;
    Any(pos: Meta): $T;
};
export declare abstract class TypeApp extends Node {
    abstract tag: "Named" | "Static" | "Function" | "Any";
    abstract match<$T>(p: $p_TypeApp<$T>): $T;
    static get Named(): typeof $$TypeApp$_Named;
    static get Static(): typeof $$TypeApp$_Static;
    static get Function(): typeof $$TypeApp$_Function;
    static get Any(): typeof $$TypeApp$_Any;
    static has_instance(x: any): boolean;
}
export declare class $$TypeApp$_Named extends TypeApp {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Named";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_TypeApp<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$TypeApp$_Static extends TypeApp {
    readonly pos: Meta;
    readonly typ: TypeApp;
    readonly tag: "Static";
    constructor(pos: Meta, typ: TypeApp);
    match<$T>(p: $p_TypeApp<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$TypeApp$_Function extends TypeApp {
    readonly pos: Meta;
    readonly args: TypeConstraint[];
    readonly ret: TypeConstraint;
    readonly tag: "Function";
    constructor(pos: Meta, args: TypeConstraint[], ret: TypeConstraint);
    match<$T>(p: $p_TypeApp<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$TypeApp$_Any extends TypeApp {
    readonly pos: Meta;
    readonly tag: "Any";
    constructor(pos: Meta);
    match<$T>(p: $p_TypeApp<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_TypeConstraint<$T> = {
    Type(pos: Meta, typ: TypeApp): $T;
    Has(pos: Meta, typ: TypeConstraint, traits: Trait[]): $T;
};
export declare abstract class TypeConstraint extends Node {
    abstract tag: "Type" | "Has";
    abstract match<$T>(p: $p_TypeConstraint<$T>): $T;
    static get Type(): typeof $$TypeConstraint$_Type;
    static get Has(): typeof $$TypeConstraint$_Has;
    static has_instance(x: any): boolean;
}
export declare class $$TypeConstraint$_Type extends TypeConstraint {
    readonly pos: Meta;
    readonly typ: TypeApp;
    readonly tag: "Type";
    constructor(pos: Meta, typ: TypeApp);
    match<$T>(p: $p_TypeConstraint<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$TypeConstraint$_Has extends TypeConstraint {
    readonly pos: Meta;
    readonly typ: TypeConstraint;
    readonly traits: Trait[];
    readonly tag: "Has";
    constructor(pos: Meta, typ: TypeConstraint, traits: Trait[]);
    match<$T>(p: $p_TypeConstraint<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Trait<$T> = {
    Named(pos: Meta, name: Name): $T;
};
export declare abstract class Trait extends Node {
    abstract tag: "Named";
    abstract match<$T>(p: $p_Trait<$T>): $T;
    static get Named(): typeof $$Trait$_Named;
    static has_instance(x: any): boolean;
}
export declare class $$Trait$_Named extends Trait {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Named";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_Trait<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Statement<$T> = {
    Fact(pos: Meta, signature: Signature<Expression>): $T;
    Forget(pos: Meta, signature: Signature<Expression>): $T;
    Let(pos: Meta, name: Name, value: Expression): $T;
    Simulate(pos: Meta, actors: Expression, context: SimulationContext, goal: SimulationGoal, signals: Signal[]): $T;
    Assert(pos: Meta, expr: Expression): $T;
    Expr(value: Expression): $T;
};
export declare abstract class Statement extends Node {
    abstract tag: "Fact" | "Forget" | "Let" | "Simulate" | "Assert" | "Expr";
    abstract match<$T>(p: $p_Statement<$T>): $T;
    static get Fact(): typeof $$Statement$_Fact;
    static get Forget(): typeof $$Statement$_Forget;
    static get Let(): typeof $$Statement$_Let;
    static get Simulate(): typeof $$Statement$_Simulate;
    static get Assert(): typeof $$Statement$_Assert;
    static get Expr(): typeof $$Statement$_Expr;
    static has_instance(x: any): boolean;
}
export declare class $$Statement$_Fact extends Statement {
    readonly pos: Meta;
    readonly signature: Signature<Expression>;
    readonly tag: "Fact";
    constructor(pos: Meta, signature: Signature<Expression>);
    match<$T>(p: $p_Statement<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Statement$_Forget extends Statement {
    readonly pos: Meta;
    readonly signature: Signature<Expression>;
    readonly tag: "Forget";
    constructor(pos: Meta, signature: Signature<Expression>);
    match<$T>(p: $p_Statement<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Statement$_Let extends Statement {
    readonly pos: Meta;
    readonly name: Name;
    readonly value: Expression;
    readonly tag: "Let";
    constructor(pos: Meta, name: Name, value: Expression);
    match<$T>(p: $p_Statement<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Statement$_Simulate extends Statement {
    readonly pos: Meta;
    readonly actors: Expression;
    readonly context: SimulationContext;
    readonly goal: SimulationGoal;
    readonly signals: Signal[];
    readonly tag: "Simulate";
    constructor(pos: Meta, actors: Expression, context: SimulationContext, goal: SimulationGoal, signals: Signal[]);
    match<$T>(p: $p_Statement<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Statement$_Assert extends Statement {
    readonly pos: Meta;
    readonly expr: Expression;
    readonly tag: "Assert";
    constructor(pos: Meta, expr: Expression);
    match<$T>(p: $p_Statement<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Statement$_Expr extends Statement {
    readonly value: Expression;
    readonly tag: "Expr";
    constructor(value: Expression);
    match<$T>(p: $p_Statement<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_SimulationContext<$T> = {
    Global(): $T;
    Named(pos: Meta, name: Name): $T;
};
export declare abstract class SimulationContext extends Node {
    abstract tag: "Global" | "Named";
    abstract match<$T>(p: $p_SimulationContext<$T>): $T;
    static get Global(): typeof $$SimulationContext$_Global;
    static get Named(): typeof $$SimulationContext$_Named;
    static has_instance(x: any): boolean;
}
export declare class $$SimulationContext$_Global extends SimulationContext {
    readonly tag: "Global";
    constructor();
    match<$T>(p: $p_SimulationContext<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$SimulationContext$_Named extends SimulationContext {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Named";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_SimulationContext<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class Signal extends Node {
    readonly pos: Meta;
    readonly signature: Signature<Parameter>;
    readonly body: Statement[];
    readonly tag: "Signal";
    constructor(pos: Meta, signature: Signature<Parameter>, body: Statement[]);
    static has_instance(x: any): boolean;
}
declare type $p_Expression<$T> = {
    New(pos: Meta, typ: Name, fields: Expression[]): $T;
    Invoke(pos: Meta, signature: Signature<Expression>): $T;
    Global(pos: Meta, name: Name): $T;
    Variable(pos: Meta, name: Name): $T;
    Self(pos: Meta): $T;
    List(pos: Meta, values: Expression[]): $T;
    Record(pos: Meta, pairs: Pair<RecordField, Expression>[]): $T;
    Search(pos: Meta, predicate: Predicate): $T;
    MatchSearch(pos: Meta, cases: MatchSearchCase[]): $T;
    Project(pos: Meta, object: Expression, field: RecordField): $T;
    Select(pos: Meta, object: Expression, fields: Projection[]): $T;
    For(pos: Meta, comprehension: ForExpression): $T;
    Block(pos: Meta, body: Statement[]): $T;
    Apply(pos: Meta, partial: Expression, values: Expression[]): $T;
    Pipe(pos: Meta, left: Expression, right: Expression): $T;
    PipeInvoke(pos: Meta, left: Expression, right: PartialSignature<Expression>): $T;
    Interpolate(pos: Meta, value: Interpolation<Expression>): $T;
    Condition(pos: Meta, cases: ConditionCase[]): $T;
    HasType(pos: Meta, value: Expression, typ: TypeApp): $T;
    HasTrait(pos: Meta, value: Expression, typ: Trait): $T;
    Force(pos: Meta, value: Expression): $T;
    Lazy(pos: Meta, value: Expression): $T;
    Hole(pos: Meta): $T;
    Return(pos: Meta): $T;
    Type(pos: Meta, typ: TypeApp): $T;
    Lambda(pos: Meta, params: Name[], body: Statement[]): $T;
    IntrinsicEqual(pos: Meta, left: Expression, right: Expression): $T;
    ForeignInvoke(pos: Meta, name: Namespace, args: Expression[]): $T;
    Parens(pos: Meta, value: Expression): $T;
    Lit(value: Literal): $T;
    Handle(pos: Meta, body: Statement[], handlers: Handler[]): $T;
    Perform(pos: Meta, effect: Name, variant: Name, args: Expression[]): $T;
    ContinueWith(pos: Meta, value: Expression): $T;
    Dsl(pos: Meta, language: TypeApp, ast: DslAst[]): $T;
};
export declare abstract class Expression extends Node {
    abstract tag: "New" | "Invoke" | "Global" | "Variable" | "Self" | "List" | "Record" | "Search" | "MatchSearch" | "Project" | "Select" | "For" | "Block" | "Apply" | "Pipe" | "PipeInvoke" | "Interpolate" | "Condition" | "HasType" | "HasTrait" | "Force" | "Lazy" | "Hole" | "Return" | "Type" | "Lambda" | "IntrinsicEqual" | "ForeignInvoke" | "Parens" | "Lit" | "Handle" | "Perform" | "ContinueWith" | "Dsl";
    abstract match<$T>(p: $p_Expression<$T>): $T;
    static get New(): typeof $$Expression$_New;
    static get Invoke(): typeof $$Expression$_Invoke;
    static get Global(): typeof $$Expression$_Global;
    static get Variable(): typeof $$Expression$_Variable;
    static get Self(): typeof $$Expression$_Self;
    static get List(): typeof $$Expression$_List;
    static get Record(): typeof $$Expression$_Record;
    static get Search(): typeof $$Expression$_Search;
    static get MatchSearch(): typeof $$Expression$_MatchSearch;
    static get Project(): typeof $$Expression$_Project;
    static get Select(): typeof $$Expression$_Select;
    static get For(): typeof $$Expression$_For;
    static get Block(): typeof $$Expression$_Block;
    static get Apply(): typeof $$Expression$_Apply;
    static get Pipe(): typeof $$Expression$_Pipe;
    static get PipeInvoke(): typeof $$Expression$_PipeInvoke;
    static get Interpolate(): typeof $$Expression$_Interpolate;
    static get Condition(): typeof $$Expression$_Condition;
    static get HasType(): typeof $$Expression$_HasType;
    static get HasTrait(): typeof $$Expression$_HasTrait;
    static get Force(): typeof $$Expression$_Force;
    static get Lazy(): typeof $$Expression$_Lazy;
    static get Hole(): typeof $$Expression$_Hole;
    static get Return(): typeof $$Expression$_Return;
    static get Type(): typeof $$Expression$_Type;
    static get Lambda(): typeof $$Expression$_Lambda;
    static get IntrinsicEqual(): typeof $$Expression$_IntrinsicEqual;
    static get ForeignInvoke(): typeof $$Expression$_ForeignInvoke;
    static get Parens(): typeof $$Expression$_Parens;
    static get Lit(): typeof $$Expression$_Lit;
    static get Handle(): typeof $$Expression$_Handle;
    static get Perform(): typeof $$Expression$_Perform;
    static get ContinueWith(): typeof $$Expression$_ContinueWith;
    static get Dsl(): typeof $$Expression$_Dsl;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_New extends Expression {
    readonly pos: Meta;
    readonly typ: Name;
    readonly fields: Expression[];
    readonly tag: "New";
    constructor(pos: Meta, typ: Name, fields: Expression[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Invoke extends Expression {
    readonly pos: Meta;
    readonly signature: Signature<Expression>;
    readonly tag: "Invoke";
    constructor(pos: Meta, signature: Signature<Expression>);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Global extends Expression {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Global";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Variable extends Expression {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Variable";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Self extends Expression {
    readonly pos: Meta;
    readonly tag: "Self";
    constructor(pos: Meta);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_List extends Expression {
    readonly pos: Meta;
    readonly values: Expression[];
    readonly tag: "List";
    constructor(pos: Meta, values: Expression[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Record extends Expression {
    readonly pos: Meta;
    readonly pairs: Pair<RecordField, Expression>[];
    readonly tag: "Record";
    constructor(pos: Meta, pairs: Pair<RecordField, Expression>[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Search extends Expression {
    readonly pos: Meta;
    readonly predicate: Predicate;
    readonly tag: "Search";
    constructor(pos: Meta, predicate: Predicate);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_MatchSearch extends Expression {
    readonly pos: Meta;
    readonly cases: MatchSearchCase[];
    readonly tag: "MatchSearch";
    constructor(pos: Meta, cases: MatchSearchCase[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Project extends Expression {
    readonly pos: Meta;
    readonly object: Expression;
    readonly field: RecordField;
    readonly tag: "Project";
    constructor(pos: Meta, object: Expression, field: RecordField);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Select extends Expression {
    readonly pos: Meta;
    readonly object: Expression;
    readonly fields: Projection[];
    readonly tag: "Select";
    constructor(pos: Meta, object: Expression, fields: Projection[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_For extends Expression {
    readonly pos: Meta;
    readonly comprehension: ForExpression;
    readonly tag: "For";
    constructor(pos: Meta, comprehension: ForExpression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Block extends Expression {
    readonly pos: Meta;
    readonly body: Statement[];
    readonly tag: "Block";
    constructor(pos: Meta, body: Statement[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Apply extends Expression {
    readonly pos: Meta;
    readonly partial: Expression;
    readonly values: Expression[];
    readonly tag: "Apply";
    constructor(pos: Meta, partial: Expression, values: Expression[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Pipe extends Expression {
    readonly pos: Meta;
    readonly left: Expression;
    readonly right: Expression;
    readonly tag: "Pipe";
    constructor(pos: Meta, left: Expression, right: Expression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_PipeInvoke extends Expression {
    readonly pos: Meta;
    readonly left: Expression;
    readonly right: PartialSignature<Expression>;
    readonly tag: "PipeInvoke";
    constructor(pos: Meta, left: Expression, right: PartialSignature<Expression>);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Interpolate extends Expression {
    readonly pos: Meta;
    readonly value: Interpolation<Expression>;
    readonly tag: "Interpolate";
    constructor(pos: Meta, value: Interpolation<Expression>);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Condition extends Expression {
    readonly pos: Meta;
    readonly cases: ConditionCase[];
    readonly tag: "Condition";
    constructor(pos: Meta, cases: ConditionCase[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_HasType extends Expression {
    readonly pos: Meta;
    readonly value: Expression;
    readonly typ: TypeApp;
    readonly tag: "HasType";
    constructor(pos: Meta, value: Expression, typ: TypeApp);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_HasTrait extends Expression {
    readonly pos: Meta;
    readonly value: Expression;
    readonly typ: Trait;
    readonly tag: "HasTrait";
    constructor(pos: Meta, value: Expression, typ: Trait);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Force extends Expression {
    readonly pos: Meta;
    readonly value: Expression;
    readonly tag: "Force";
    constructor(pos: Meta, value: Expression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Lazy extends Expression {
    readonly pos: Meta;
    readonly value: Expression;
    readonly tag: "Lazy";
    constructor(pos: Meta, value: Expression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Hole extends Expression {
    readonly pos: Meta;
    readonly tag: "Hole";
    constructor(pos: Meta);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Return extends Expression {
    readonly pos: Meta;
    readonly tag: "Return";
    constructor(pos: Meta);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Type extends Expression {
    readonly pos: Meta;
    readonly typ: TypeApp;
    readonly tag: "Type";
    constructor(pos: Meta, typ: TypeApp);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Lambda extends Expression {
    readonly pos: Meta;
    readonly params: Name[];
    readonly body: Statement[];
    readonly tag: "Lambda";
    constructor(pos: Meta, params: Name[], body: Statement[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_IntrinsicEqual extends Expression {
    readonly pos: Meta;
    readonly left: Expression;
    readonly right: Expression;
    readonly tag: "IntrinsicEqual";
    constructor(pos: Meta, left: Expression, right: Expression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_ForeignInvoke extends Expression {
    readonly pos: Meta;
    readonly name: Namespace;
    readonly args: Expression[];
    readonly tag: "ForeignInvoke";
    constructor(pos: Meta, name: Namespace, args: Expression[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Parens extends Expression {
    readonly pos: Meta;
    readonly value: Expression;
    readonly tag: "Parens";
    constructor(pos: Meta, value: Expression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Lit extends Expression {
    readonly value: Literal;
    readonly tag: "Lit";
    constructor(value: Literal);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Handle extends Expression {
    readonly pos: Meta;
    readonly body: Statement[];
    readonly handlers: Handler[];
    readonly tag: "Handle";
    constructor(pos: Meta, body: Statement[], handlers: Handler[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Perform extends Expression {
    readonly pos: Meta;
    readonly effect: Name;
    readonly variant: Name;
    readonly args: Expression[];
    readonly tag: "Perform";
    constructor(pos: Meta, effect: Name, variant: Name, args: Expression[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_ContinueWith extends Expression {
    readonly pos: Meta;
    readonly value: Expression;
    readonly tag: "ContinueWith";
    constructor(pos: Meta, value: Expression);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Expression$_Dsl extends Expression {
    readonly pos: Meta;
    readonly language: TypeApp;
    readonly ast: DslAst[];
    readonly tag: "Dsl";
    constructor(pos: Meta, language: TypeApp, ast: DslAst[]);
    match<$T>(p: $p_Expression<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_DslAst<$T> = {
    Node(pos: Meta, sig: DslSignature<DslAst>[], attrs: DslAttr[]): $T;
    Lit(pos: Meta, value: Literal): $T;
    Var(pos: Meta, name: Name): $T;
    List(pos: Meta, values: DslAst[]): $T;
    Interpolation(pos: Meta, parts: Interpolation<DslAst>): $T;
    Dynamic(pos: Meta, value: Expression): $T;
};
export declare abstract class DslAst extends Node {
    abstract tag: "Node" | "Lit" | "Var" | "List" | "Interpolation" | "Dynamic";
    abstract match<$T>(p: $p_DslAst<$T>): $T;
    static get Node(): typeof $$DslAst$_Node;
    static get Lit(): typeof $$DslAst$_Lit;
    static get Var(): typeof $$DslAst$_Var;
    static get List(): typeof $$DslAst$_List;
    static get Interpolation(): typeof $$DslAst$_Interpolation;
    static get Dynamic(): typeof $$DslAst$_Dynamic;
    static has_instance(x: any): boolean;
}
export declare class $$DslAst$_Node extends DslAst {
    readonly pos: Meta;
    readonly sig: DslSignature<DslAst>[];
    readonly attrs: DslAttr[];
    readonly tag: "Node";
    constructor(pos: Meta, sig: DslSignature<DslAst>[], attrs: DslAttr[]);
    match<$T>(p: $p_DslAst<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$DslAst$_Lit extends DslAst {
    readonly pos: Meta;
    readonly value: Literal;
    readonly tag: "Lit";
    constructor(pos: Meta, value: Literal);
    match<$T>(p: $p_DslAst<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$DslAst$_Var extends DslAst {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Var";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_DslAst<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$DslAst$_List extends DslAst {
    readonly pos: Meta;
    readonly values: DslAst[];
    readonly tag: "List";
    constructor(pos: Meta, values: DslAst[]);
    match<$T>(p: $p_DslAst<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$DslAst$_Interpolation extends DslAst {
    readonly pos: Meta;
    readonly parts: Interpolation<DslAst>;
    readonly tag: "Interpolation";
    constructor(pos: Meta, parts: Interpolation<DslAst>);
    match<$T>(p: $p_DslAst<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$DslAst$_Dynamic extends DslAst {
    readonly pos: Meta;
    readonly value: Expression;
    readonly tag: "Dynamic";
    constructor(pos: Meta, value: Expression);
    match<$T>(p: $p_DslAst<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_DslSignature<T, $T> = {
    Name(name: Name): $T;
    Child(value: T): $T;
};
export declare abstract class DslSignature<T> extends Node {
    abstract tag: "Name" | "Child";
    abstract match<$T>(p: $p_DslSignature<T, $T>): $T;
    static get Name(): typeof $$DslSignature$_Name;
    static get Child(): typeof $$DslSignature$_Child;
    static has_instance(x: any): boolean;
}
export declare class $$DslSignature$_Name<T> extends DslSignature<T> {
    readonly name: Name;
    readonly tag: "Name";
    constructor(name: Name);
    match<$T>(p: $p_DslSignature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$DslSignature$_Child<T> extends DslSignature<T> {
    readonly value: T;
    readonly tag: "Child";
    constructor(value: T);
    match<$T>(p: $p_DslSignature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class DslAttr extends Node {
    readonly pos: Meta;
    readonly key: Name;
    readonly value: DslAst;
    readonly tag: "DslAttr";
    constructor(pos: Meta, key: Name, value: DslAst);
    static has_instance(x: any): boolean;
}
declare type $p_ForExpression<$T> = {
    Map(pos: Meta, name: Name, stream: Expression, body: ForExpression): $T;
    If(pos: Meta, condition: Expression, body: ForExpression): $T;
    Do(pos: Meta, body: Expression): $T;
};
export declare abstract class ForExpression extends Node {
    abstract tag: "Map" | "If" | "Do";
    abstract match<$T>(p: $p_ForExpression<$T>): $T;
    static get Map(): typeof $$ForExpression$_Map;
    static get If(): typeof $$ForExpression$_If;
    static get Do(): typeof $$ForExpression$_Do;
    static has_instance(x: any): boolean;
}
export declare class $$ForExpression$_Map extends ForExpression {
    readonly pos: Meta;
    readonly name: Name;
    readonly stream: Expression;
    readonly body: ForExpression;
    readonly tag: "Map";
    constructor(pos: Meta, name: Name, stream: Expression, body: ForExpression);
    match<$T>(p: $p_ForExpression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ForExpression$_If extends ForExpression {
    readonly pos: Meta;
    readonly condition: Expression;
    readonly body: ForExpression;
    readonly tag: "If";
    constructor(pos: Meta, condition: Expression, body: ForExpression);
    match<$T>(p: $p_ForExpression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ForExpression$_Do extends ForExpression {
    readonly pos: Meta;
    readonly body: Expression;
    readonly tag: "Do";
    constructor(pos: Meta, body: Expression);
    match<$T>(p: $p_ForExpression<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class MatchSearchCase extends Node {
    readonly pos: Meta;
    readonly predicate: Predicate;
    readonly body: Statement[];
    readonly tag: "MatchSearchCase";
    constructor(pos: Meta, predicate: Predicate, body: Statement[]);
    static has_instance(x: any): boolean;
}
export declare class ConditionCase extends Node {
    readonly pos: Meta;
    readonly guard: Expression;
    readonly body: Statement[];
    readonly tag: "ConditionCase";
    constructor(pos: Meta, guard: Expression, body: Statement[]);
    static has_instance(x: any): boolean;
}
declare type $p_RecordField<$T> = {
    FName(value: Name): $T;
    FText(value: String): $T;
    FComputed(value: Expression): $T;
};
export declare abstract class RecordField extends Node {
    abstract tag: "FName" | "FText" | "FComputed";
    abstract match<$T>(p: $p_RecordField<$T>): $T;
    static get FName(): typeof $$RecordField$_FName;
    static get FText(): typeof $$RecordField$_FText;
    static get FComputed(): typeof $$RecordField$_FComputed;
    static has_instance(x: any): boolean;
}
export declare class $$RecordField$_FName extends RecordField {
    readonly value: Name;
    readonly tag: "FName";
    constructor(value: Name);
    match<$T>(p: $p_RecordField<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$RecordField$_FText extends RecordField {
    readonly value: String;
    readonly tag: "FText";
    constructor(value: String);
    match<$T>(p: $p_RecordField<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$RecordField$_FComputed extends RecordField {
    readonly value: Expression;
    readonly tag: "FComputed";
    constructor(value: Expression);
    match<$T>(p: $p_RecordField<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class Projection extends Node {
    readonly pos: Meta;
    readonly name: RecordField;
    readonly alias: RecordField;
    readonly tag: "Projection";
    constructor(pos: Meta, name: RecordField, alias: RecordField);
    static has_instance(x: any): boolean;
}
export declare class Interpolation<T> extends Node {
    readonly pos: Meta;
    readonly parts: InterpolationPart<T>[];
    readonly tag: "Interpolation";
    constructor(pos: Meta, parts: InterpolationPart<T>[]);
    static has_instance(x: any): boolean;
}
declare type $p_InterpolationPart<T, $T> = {
    Escape(pos: Meta, character: string): $T;
    Static(pos: Meta, text: string): $T;
    Dynamic(pos: Meta, value: T): $T;
};
export declare abstract class InterpolationPart<T> extends Node {
    abstract tag: "Escape" | "Static" | "Dynamic";
    abstract match<$T>(p: $p_InterpolationPart<T, $T>): $T;
    static get Escape(): typeof $$InterpolationPart$_Escape;
    static get Static(): typeof $$InterpolationPart$_Static;
    static get Dynamic(): typeof $$InterpolationPart$_Dynamic;
    static has_instance(x: any): boolean;
}
export declare class $$InterpolationPart$_Escape<T> extends InterpolationPart<T> {
    readonly pos: Meta;
    readonly character: string;
    readonly tag: "Escape";
    constructor(pos: Meta, character: string);
    match<$T>(p: $p_InterpolationPart<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$InterpolationPart$_Static<T> extends InterpolationPart<T> {
    readonly pos: Meta;
    readonly text: string;
    readonly tag: "Static";
    constructor(pos: Meta, text: string);
    match<$T>(p: $p_InterpolationPart<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$InterpolationPart$_Dynamic<T> extends InterpolationPart<T> {
    readonly pos: Meta;
    readonly value: T;
    readonly tag: "Dynamic";
    constructor(pos: Meta, value: T);
    match<$T>(p: $p_InterpolationPart<T, $T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Literal<$T> = {
    False(pos: Meta): $T;
    True(pos: Meta): $T;
    Nothing(pos: Meta): $T;
    Text(pos: Meta, value: String): $T;
    Integer(pos: Meta, digits: string): $T;
    Float(pos: Meta, digits: string): $T;
};
export declare abstract class Literal extends Node {
    abstract tag: "False" | "True" | "Nothing" | "Text" | "Integer" | "Float";
    abstract match<$T>(p: $p_Literal<$T>): $T;
    static get False(): typeof $$Literal$_False;
    static get True(): typeof $$Literal$_True;
    static get Nothing(): typeof $$Literal$_Nothing;
    static get Text(): typeof $$Literal$_Text;
    static get Integer(): typeof $$Literal$_Integer;
    static get Float(): typeof $$Literal$_Float;
    static has_instance(x: any): boolean;
}
export declare class $$Literal$_False extends Literal {
    readonly pos: Meta;
    readonly tag: "False";
    constructor(pos: Meta);
    match<$T>(p: $p_Literal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Literal$_True extends Literal {
    readonly pos: Meta;
    readonly tag: "True";
    constructor(pos: Meta);
    match<$T>(p: $p_Literal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Literal$_Nothing extends Literal {
    readonly pos: Meta;
    readonly tag: "Nothing";
    constructor(pos: Meta);
    match<$T>(p: $p_Literal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Literal$_Text extends Literal {
    readonly pos: Meta;
    readonly value: String;
    readonly tag: "Text";
    constructor(pos: Meta, value: String);
    match<$T>(p: $p_Literal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Literal$_Integer extends Literal {
    readonly pos: Meta;
    readonly digits: string;
    readonly tag: "Integer";
    constructor(pos: Meta, digits: string);
    match<$T>(p: $p_Literal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Literal$_Float extends Literal {
    readonly pos: Meta;
    readonly digits: string;
    readonly tag: "Float";
    constructor(pos: Meta, digits: string);
    match<$T>(p: $p_Literal<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_SimulationGoal<$T> = {
    ActionQuiescence(pos: Meta): $T;
    EventQuiescence(pos: Meta): $T;
    TotalQuiescence(pos: Meta): $T;
    CustomGoal(pos: Meta, pred: Predicate): $T;
};
export declare abstract class SimulationGoal extends Node {
    abstract tag: "ActionQuiescence" | "EventQuiescence" | "TotalQuiescence" | "CustomGoal";
    abstract match<$T>(p: $p_SimulationGoal<$T>): $T;
    static get ActionQuiescence(): typeof $$SimulationGoal$_ActionQuiescence;
    static get EventQuiescence(): typeof $$SimulationGoal$_EventQuiescence;
    static get TotalQuiescence(): typeof $$SimulationGoal$_TotalQuiescence;
    static get CustomGoal(): typeof $$SimulationGoal$_CustomGoal;
    static has_instance(x: any): boolean;
}
export declare class $$SimulationGoal$_ActionQuiescence extends SimulationGoal {
    readonly pos: Meta;
    readonly tag: "ActionQuiescence";
    constructor(pos: Meta);
    match<$T>(p: $p_SimulationGoal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$SimulationGoal$_EventQuiescence extends SimulationGoal {
    readonly pos: Meta;
    readonly tag: "EventQuiescence";
    constructor(pos: Meta);
    match<$T>(p: $p_SimulationGoal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$SimulationGoal$_TotalQuiescence extends SimulationGoal {
    readonly pos: Meta;
    readonly tag: "TotalQuiescence";
    constructor(pos: Meta);
    match<$T>(p: $p_SimulationGoal<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$SimulationGoal$_CustomGoal extends SimulationGoal {
    readonly pos: Meta;
    readonly pred: Predicate;
    readonly tag: "CustomGoal";
    constructor(pos: Meta, pred: Predicate);
    match<$T>(p: $p_SimulationGoal<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Predicate<$T> = {
    And(pos: Meta, left: Predicate, right: Predicate): $T;
    Or(pos: Meta, left: Predicate, right: Predicate): $T;
    Not(pos: Meta, pred: Predicate): $T;
    Has(pos: Meta, signature: Signature<Pattern>): $T;
    Sample(pos: Meta, size: Literal, pool: SamplingPool): $T;
    Constrain(pos: Meta, pred: Predicate, constraint: Expression): $T;
    Let(pos: Meta, name: Name, value: Expression): $T;
    Typed(pos: Meta, name: Name, typ: TypeApp): $T;
    Always(pos: Meta): $T;
    Parens(pos: Meta, pred: Predicate): $T;
};
export declare abstract class Predicate extends Node {
    abstract tag: "And" | "Or" | "Not" | "Has" | "Sample" | "Constrain" | "Let" | "Typed" | "Always" | "Parens";
    abstract match<$T>(p: $p_Predicate<$T>): $T;
    static get And(): typeof $$Predicate$_And;
    static get Or(): typeof $$Predicate$_Or;
    static get Not(): typeof $$Predicate$_Not;
    static get Has(): typeof $$Predicate$_Has;
    static get Sample(): typeof $$Predicate$_Sample;
    static get Constrain(): typeof $$Predicate$_Constrain;
    static get Let(): typeof $$Predicate$_Let;
    static get Typed(): typeof $$Predicate$_Typed;
    static get Always(): typeof $$Predicate$_Always;
    static get Parens(): typeof $$Predicate$_Parens;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_And extends Predicate {
    readonly pos: Meta;
    readonly left: Predicate;
    readonly right: Predicate;
    readonly tag: "And";
    constructor(pos: Meta, left: Predicate, right: Predicate);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Or extends Predicate {
    readonly pos: Meta;
    readonly left: Predicate;
    readonly right: Predicate;
    readonly tag: "Or";
    constructor(pos: Meta, left: Predicate, right: Predicate);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Not extends Predicate {
    readonly pos: Meta;
    readonly pred: Predicate;
    readonly tag: "Not";
    constructor(pos: Meta, pred: Predicate);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Has extends Predicate {
    readonly pos: Meta;
    readonly signature: Signature<Pattern>;
    readonly tag: "Has";
    constructor(pos: Meta, signature: Signature<Pattern>);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Sample extends Predicate {
    readonly pos: Meta;
    readonly size: Literal;
    readonly pool: SamplingPool;
    readonly tag: "Sample";
    constructor(pos: Meta, size: Literal, pool: SamplingPool);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Constrain extends Predicate {
    readonly pos: Meta;
    readonly pred: Predicate;
    readonly constraint: Expression;
    readonly tag: "Constrain";
    constructor(pos: Meta, pred: Predicate, constraint: Expression);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Let extends Predicate {
    readonly pos: Meta;
    readonly name: Name;
    readonly value: Expression;
    readonly tag: "Let";
    constructor(pos: Meta, name: Name, value: Expression);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Typed extends Predicate {
    readonly pos: Meta;
    readonly name: Name;
    readonly typ: TypeApp;
    readonly tag: "Typed";
    constructor(pos: Meta, name: Name, typ: TypeApp);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Always extends Predicate {
    readonly pos: Meta;
    readonly tag: "Always";
    constructor(pos: Meta);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Predicate$_Parens extends Predicate {
    readonly pos: Meta;
    readonly pred: Predicate;
    readonly tag: "Parens";
    constructor(pos: Meta, pred: Predicate);
    match<$T>(p: $p_Predicate<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_SamplingPool<$T> = {
    Relation(pos: Meta, signature: Signature<Pattern>): $T;
    Type(pos: Meta, name: Name, typ: TypeApp): $T;
};
export declare abstract class SamplingPool extends Node {
    abstract tag: "Relation" | "Type";
    abstract match<$T>(p: $p_SamplingPool<$T>): $T;
    static get Relation(): typeof $$SamplingPool$_Relation;
    static get Type(): typeof $$SamplingPool$_Type;
    static has_instance(x: any): boolean;
}
export declare class $$SamplingPool$_Relation extends SamplingPool {
    readonly pos: Meta;
    readonly signature: Signature<Pattern>;
    readonly tag: "Relation";
    constructor(pos: Meta, signature: Signature<Pattern>);
    match<$T>(p: $p_SamplingPool<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$SamplingPool$_Type extends SamplingPool {
    readonly pos: Meta;
    readonly name: Name;
    readonly typ: TypeApp;
    readonly tag: "Type";
    constructor(pos: Meta, name: Name, typ: TypeApp);
    match<$T>(p: $p_SamplingPool<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Pattern<$T> = {
    HasType(pos: Meta, typ: TypeApp, name: Pattern): $T;
    StaticType(pos: Meta, typ: TypeApp): $T;
    Global(pos: Meta, name: Name): $T;
    Variable(pos: Meta, name: Name): $T;
    Self(pos: Meta): $T;
    Wildcard(pos: Meta): $T;
    Lit(lit: Literal): $T;
};
export declare abstract class Pattern extends Node {
    abstract tag: "HasType" | "StaticType" | "Global" | "Variable" | "Self" | "Wildcard" | "Lit";
    abstract match<$T>(p: $p_Pattern<$T>): $T;
    static get HasType(): typeof $$Pattern$_HasType;
    static get StaticType(): typeof $$Pattern$_StaticType;
    static get Global(): typeof $$Pattern$_Global;
    static get Variable(): typeof $$Pattern$_Variable;
    static get Self(): typeof $$Pattern$_Self;
    static get Wildcard(): typeof $$Pattern$_Wildcard;
    static get Lit(): typeof $$Pattern$_Lit;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_HasType extends Pattern {
    readonly pos: Meta;
    readonly typ: TypeApp;
    readonly name: Pattern;
    readonly tag: "HasType";
    constructor(pos: Meta, typ: TypeApp, name: Pattern);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_StaticType extends Pattern {
    readonly pos: Meta;
    readonly typ: TypeApp;
    readonly tag: "StaticType";
    constructor(pos: Meta, typ: TypeApp);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_Global extends Pattern {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Global";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_Variable extends Pattern {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Variable";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_Self extends Pattern {
    readonly pos: Meta;
    readonly tag: "Self";
    constructor(pos: Meta);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_Wildcard extends Pattern {
    readonly pos: Meta;
    readonly tag: "Wildcard";
    constructor(pos: Meta);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Pattern$_Lit extends Pattern {
    readonly lit: Literal;
    readonly tag: "Lit";
    constructor(lit: Literal);
    match<$T>(p: $p_Pattern<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_Signature<T, $T> = {
    Unary(pos: Meta, self: T, name: Name): $T;
    Binary(pos: Meta, op: Name, left: T, right: T): $T;
    Keyword(pos: Meta, self: T, pairs: Pair<Name, T>[]): $T;
    KeywordSelfless(pos: Meta, pairs: Pair<Name, T>[]): $T;
};
export declare abstract class Signature<T> extends Node {
    abstract tag: "Unary" | "Binary" | "Keyword" | "KeywordSelfless";
    abstract match<$T>(p: $p_Signature<T, $T>): $T;
    static get Unary(): typeof $$Signature$_Unary;
    static get Binary(): typeof $$Signature$_Binary;
    static get Keyword(): typeof $$Signature$_Keyword;
    static get KeywordSelfless(): typeof $$Signature$_KeywordSelfless;
    static has_instance(x: any): boolean;
}
export declare class $$Signature$_Unary<T> extends Signature<T> {
    readonly pos: Meta;
    readonly self: T;
    readonly name: Name;
    readonly tag: "Unary";
    constructor(pos: Meta, self: T, name: Name);
    match<$T>(p: $p_Signature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Signature$_Binary<T> extends Signature<T> {
    readonly pos: Meta;
    readonly op: Name;
    readonly left: T;
    readonly right: T;
    readonly tag: "Binary";
    constructor(pos: Meta, op: Name, left: T, right: T);
    match<$T>(p: $p_Signature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Signature$_Keyword<T> extends Signature<T> {
    readonly pos: Meta;
    readonly self: T;
    readonly pairs: Pair<Name, T>[];
    readonly tag: "Keyword";
    constructor(pos: Meta, self: T, pairs: Pair<Name, T>[]);
    match<$T>(p: $p_Signature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$Signature$_KeywordSelfless<T> extends Signature<T> {
    readonly pos: Meta;
    readonly pairs: Pair<Name, T>[];
    readonly tag: "KeywordSelfless";
    constructor(pos: Meta, pairs: Pair<Name, T>[]);
    match<$T>(p: $p_Signature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_PartialSignature<T, $T> = {
    Unary(pos: Meta, name: Name): $T;
    Binary(pos: Meta, op: Name, right: T): $T;
    Keyword(pos: Meta, pairs: Pair<Name, T>[]): $T;
};
export declare abstract class PartialSignature<T> extends Node {
    abstract tag: "Unary" | "Binary" | "Keyword";
    abstract match<$T>(p: $p_PartialSignature<T, $T>): $T;
    static get Unary(): typeof $$PartialSignature$_Unary;
    static get Binary(): typeof $$PartialSignature$_Binary;
    static get Keyword(): typeof $$PartialSignature$_Keyword;
    static has_instance(x: any): boolean;
}
export declare class $$PartialSignature$_Unary<T> extends PartialSignature<T> {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Unary";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_PartialSignature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$PartialSignature$_Binary<T> extends PartialSignature<T> {
    readonly pos: Meta;
    readonly op: Name;
    readonly right: T;
    readonly tag: "Binary";
    constructor(pos: Meta, op: Name, right: T);
    match<$T>(p: $p_PartialSignature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$PartialSignature$_Keyword<T> extends PartialSignature<T> {
    readonly pos: Meta;
    readonly pairs: Pair<Name, T>[];
    readonly tag: "Keyword";
    constructor(pos: Meta, pairs: Pair<Name, T>[]);
    match<$T>(p: $p_PartialSignature<T, $T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_RelationPart<$T> = {
    Many(pos: Meta, name: Name): $T;
    One(pos: Meta, name: Name): $T;
};
export declare abstract class RelationPart extends Node {
    abstract tag: "Many" | "One";
    abstract match<$T>(p: $p_RelationPart<$T>): $T;
    static get Many(): typeof $$RelationPart$_Many;
    static get One(): typeof $$RelationPart$_One;
    static has_instance(x: any): boolean;
}
export declare class $$RelationPart$_Many extends RelationPart {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "Many";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_RelationPart<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$RelationPart$_One extends RelationPart {
    readonly pos: Meta;
    readonly name: Name;
    readonly tag: "One";
    constructor(pos: Meta, name: Name);
    match<$T>(p: $p_RelationPart<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class Pair<K, V> extends Node {
    readonly pos: Meta;
    readonly key: K;
    readonly value: V;
    readonly tag: "Pair";
    constructor(pos: Meta, key: K, value: V);
    static has_instance(x: any): boolean;
}
export declare class Name extends Node {
    readonly pos: Meta;
    readonly name: string;
    readonly tag: "Name";
    constructor(pos: Meta, name: string);
    static has_instance(x: any): boolean;
}
export declare class Namespace extends Node {
    readonly pos: Meta;
    readonly names: string[];
    readonly tag: "Namespace";
    constructor(pos: Meta, names: string[]);
    static has_instance(x: any): boolean;
}
export declare class String extends Node {
    readonly pos: Meta;
    readonly text: string;
    readonly tag: "String";
    constructor(pos: Meta, text: string);
    static has_instance(x: any): boolean;
}
declare type $p_REPL<$T> = {
    Declarations(x: Declaration[]): $T;
    Statements(x: Statement[]): $T;
    Command(x: ReplCommand): $T;
};
export declare abstract class REPL extends Node {
    abstract tag: "Declarations" | "Statements" | "Command";
    abstract match<$T>(p: $p_REPL<$T>): $T;
    static get Declarations(): typeof $$REPL$_Declarations;
    static get Statements(): typeof $$REPL$_Statements;
    static get Command(): typeof $$REPL$_Command;
    static has_instance(x: any): boolean;
}
export declare class $$REPL$_Declarations extends REPL {
    readonly x: Declaration[];
    readonly tag: "Declarations";
    constructor(x: Declaration[]);
    match<$T>(p: $p_REPL<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$REPL$_Statements extends REPL {
    readonly x: Statement[];
    readonly tag: "Statements";
    constructor(x: Statement[]);
    match<$T>(p: $p_REPL<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$REPL$_Command extends REPL {
    readonly x: ReplCommand;
    readonly tag: "Command";
    constructor(x: ReplCommand);
    match<$T>(p: $p_REPL<$T>): $T;
    static has_instance(x: any): boolean;
}
declare type $p_ReplCommand<$T> = {
    Rollback(sig: Signature<Expression>): $T;
    HelpCommand(sig: Signature<Parameter>): $T;
    HelpType(typ: TypeApp): $T;
};
export declare abstract class ReplCommand extends Node {
    abstract tag: "Rollback" | "HelpCommand" | "HelpType";
    abstract match<$T>(p: $p_ReplCommand<$T>): $T;
    static get Rollback(): typeof $$ReplCommand$_Rollback;
    static get HelpCommand(): typeof $$ReplCommand$_HelpCommand;
    static get HelpType(): typeof $$ReplCommand$_HelpType;
    static has_instance(x: any): boolean;
}
export declare class $$ReplCommand$_Rollback extends ReplCommand {
    readonly sig: Signature<Expression>;
    readonly tag: "Rollback";
    constructor(sig: Signature<Expression>);
    match<$T>(p: $p_ReplCommand<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ReplCommand$_HelpCommand extends ReplCommand {
    readonly sig: Signature<Parameter>;
    readonly tag: "HelpCommand";
    constructor(sig: Signature<Parameter>);
    match<$T>(p: $p_ReplCommand<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare class $$ReplCommand$_HelpType extends ReplCommand {
    readonly typ: TypeApp;
    readonly tag: "HelpType";
    constructor(typ: TypeApp);
    match<$T>(p: $p_ReplCommand<$T>): $T;
    static has_instance(x: any): boolean;
}
export declare const grammar: Ohm.Grammar;
export declare function parse(source: string, rule: string): Result<Program>;
export declare const semantics: Ohm.Semantics;
export declare const toAstVisitor: {
    _terminal(this: Ohm.Node): any;
    _iter(this: any, children: Ohm.Node): any;
    nonemptyListOf(first: Ohm.Node, _: Ohm.Node, rest: Ohm.Node): any;
    emptyListOf(): any;
    NonemptyListOf(first: Ohm.Node, _: Ohm.Node, rest: Ohm.Node): any;
    EmptyListOf(): any;
    program(x: Ohm.Node): any;
    program_alt1(this: Ohm.Node, _1: Ohm.Node, ds$0: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node): any;
    repl(x: Ohm.Node): any;
    repl_alt1(this: Ohm.Node, _1: Ohm.Node, ds$0: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node): any;
    repl_alt2(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node): any;
    repl_alt3(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node): any;
    replCommand(x: Ohm.Node): any;
    replCommand_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, s$0: Ohm.Node): any;
    replCommand_alt2(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node): any;
    replCommand_alt3(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node): any;
    declarationMeta(x: Ohm.Node): any;
    declarationMeta_alt1(this: Ohm.Node, _1: Ohm.Node, d$0: Ohm.Node): any;
    meta_doc(x: Ohm.Node): any;
    meta_doc_alt1(this: Ohm.Node, d$0: Ohm.Node): any;
    meta_doc_alt2(this: Ohm.Node): any;
    declaration(x: Ohm.Node): any;
    declaration_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt8(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt9(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt10(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt11(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt12(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt13(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt14(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt15(this: Ohm.Node, _1: Ohm.Node): any;
    declaration_alt16(this: Ohm.Node, _1: Ohm.Node): any;
    capabilityDeclaration(x: Ohm.Node): any;
    capabilityDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, n$0: Ohm.Node, _4: Ohm.Node): any;
    protectDeclaration(x: Ohm.Node): any;
    protectDeclaration_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, _3: Ohm.Node, c$0: Ohm.Node, _5: Ohm.Node): any;
    protectEntity(x: Ohm.Node): any;
    protectEntity_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node): any;
    protectEntity_alt2(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node): any;
    protectEntity_alt3(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node): any;
    protectEntity_alt4(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node): any;
    traitDeclaration(x: Ohm.Node): any;
    traitDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, n$0: Ohm.Node, _4: Ohm.Node, cs$0: Ohm.Node, _6: Ohm.Node): any;
    traitDeclaration_alt2(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, n$0: Ohm.Node, _4: Ohm.Node): any;
    traitInstruction(x: Ohm.Node): any;
    traitInstruction_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    traitInstruction_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    traitCommand(x: Ohm.Node): any;
    traitCommand_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node, _5: Ohm.Node): any;
    traitRequires(x: Ohm.Node): any;
    traitRequires_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, n$0: Ohm.Node, _4: Ohm.Node): any;
    traitImplementDeclaration(x: Ohm.Node): any;
    traitImplementDeclaration_alt1(this: Ohm.Node, _1: Ohm.Node, tr$0: Ohm.Node, _3: Ohm.Node, tp$0: Ohm.Node, _5: Ohm.Node): any;
    effectDeclaration(x: Ohm.Node): any;
    effectDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, n$0: Ohm.Node, _4: Ohm.Node, cs$0: Ohm.Node, _6: Ohm.Node): any;
    effectCase(x: Ohm.Node): any;
    effectCase_alt1(this: Ohm.Node, m$0: Ohm.Node, s$0: Ohm.Node, xs$0: Ohm.Node, _4: Ohm.Node): any;
    effectCaseParams(x: Ohm.Node): any;
    effectCaseParams_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    testDeclaration(x: Ohm.Node): any;
    testDeclaration_alt1(this: Ohm.Node, _1: Ohm.Node, s$0: Ohm.Node, _3: Ohm.Node, b$0: Ohm.Node, _5: Ohm.Node): any;
    trailingTest(x: Ohm.Node): any;
    trailingTest_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    trailingTest_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    oneTrailingTest(x: Ohm.Node): any;
    oneTrailingTest_alt1(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node, _3: Ohm.Node): any;
    localDeclaration(x: Ohm.Node): any;
    localDeclaration_alt1(this: Ohm.Node, _1: Ohm.Node, d$0: Ohm.Node): any;
    localDeclaration_alt2(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node): any;
    openDeclaration(x: Ohm.Node): any;
    openDeclaration_alt1(this: Ohm.Node, _1: Ohm.Node, ns$0: Ohm.Node, _3: Ohm.Node): any;
    relationDeclaration(x: Ohm.Node): any;
    relationDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, _5: Ohm.Node): any;
    relationPart(x: Ohm.Node): any;
    relationPart_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node): any;
    relationPart_alt2(this: Ohm.Node, n$0: Ohm.Node): any;
    doDeclaration(x: Ohm.Node): any;
    doDeclaration_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    commandDeclaration(x: Ohm.Node): any;
    commandDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, c$0: Ohm.Node, _6: Ohm.Node, e$0: Ohm.Node, t$0: Ohm.Node): any;
    commandDeclaration_alt2(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, c$0: Ohm.Node, _6: Ohm.Node, b$0: Ohm.Node, t$0: Ohm.Node): any;
    commandDeclaration_alt3(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, c$0: Ohm.Node, _6: Ohm.Node, b$0: Ohm.Node, _8: Ohm.Node): any;
    contractDefinition(x: Ohm.Node): any;
    contractDefinition_alt1(this: Ohm.Node, ret$0: Ohm.Node, pre$0: Ohm.Node, post$0: Ohm.Node): any;
    retContractDefinition(x: Ohm.Node): any;
    retContractDefinition_alt1(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node): any;
    retContractDefinition_alt2(this: Ohm.Node): any;
    preContractDefinition(x: Ohm.Node): any;
    preContractDefinition_alt1(this: Ohm.Node, _1: Ohm.Node, cs$0: Ohm.Node): any;
    preContractDefinition_alt2(this: Ohm.Node): any;
    postContractDefinition(x: Ohm.Node): any;
    postContractDefinition_alt1(this: Ohm.Node, _1: Ohm.Node, cs$0: Ohm.Node): any;
    postContractDefinition_alt2(this: Ohm.Node): any;
    contractCondition(x: Ohm.Node): any;
    contractCondition_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, e$0: Ohm.Node): any;
    parameter(x: Ohm.Node): any;
    parameter_alt1(this: Ohm.Node, n$0: Ohm.Node): any;
    parameter_alt2(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node, _5: Ohm.Node): any;
    parameter_alt3(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, trs$0: Ohm.Node, _5: Ohm.Node): any;
    parameter_alt4(this: Ohm.Node, t$0: Ohm.Node): any;
    typeConstraint(x: Ohm.Node): any;
    typeConstraint_alt1(this: Ohm.Node, t$0: Ohm.Node, _2: Ohm.Node, trs$0: Ohm.Node): any;
    typeConstraint_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeConstraint1(x: Ohm.Node): any;
    typeConstraint1_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, c$0: Ohm.Node): any;
    typeConstraint1_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeConstraintPrimary(x: Ohm.Node): any;
    typeConstraintPrimary_alt1(this: Ohm.Node, n$0: Ohm.Node): any;
    typeConstraintPrimary_alt2(this: Ohm.Node, t$0: Ohm.Node): any;
    typeConstraintPrimary_alt3(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node, _3: Ohm.Node): any;
    typeApp(x: Ohm.Node): any;
    typeApp_alt1(this: Ohm.Node, ts$0: Ohm.Node, _2: Ohm.Node, t$0: Ohm.Node): any;
    typeApp_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeAppArgs(x: Ohm.Node): any;
    typeAppArgs_alt1(this: Ohm.Node, _1: Ohm.Node, ts$0: Ohm.Node, _3: Ohm.Node): any;
    typeAppArgs_alt2(this: Ohm.Node, t$0: Ohm.Node): any;
    typeApp1(x: Ohm.Node): any;
    typeApp1_alt1(this: Ohm.Node, t$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node): any;
    typeApp1_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeAppStatic(x: Ohm.Node): any;
    typeAppStatic_alt1(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node): any;
    typeAppStatic_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeAppPrimary(x: Ohm.Node): any;
    typeAppPrimary_alt1(this: Ohm.Node, t$0: Ohm.Node): any;
    typeAppPrimary_alt2(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node, _3: Ohm.Node): any;
    typeName(x: Ohm.Node): any;
    typeName_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    typeName_alt2(this: Ohm.Node, x$0: Ohm.Node): any;
    typeName_alt3(this: Ohm.Node, x$0: Ohm.Node): any;
    typeName_alt4(this: Ohm.Node, x$0: Ohm.Node): any;
    traitName(x: Ohm.Node): any;
    traitName_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    typeDeclaration(x: Ohm.Node): any;
    typeDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node, _5: Ohm.Node, _6: Ohm.Node, n$0: Ohm.Node, _8: Ohm.Node): any;
    typeDeclaration_alt2(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node, _5: Ohm.Node, vs$0: Ohm.Node, _7: Ohm.Node): any;
    typeDeclaration_alt3(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node, _5: Ohm.Node): any;
    typeDeclaration_alt4(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node, i$0: Ohm.Node): any;
    typeDeclaration_alt5(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, n$0: Ohm.Node, fs$0: Ohm.Node, p$0: Ohm.Node, _7: Ohm.Node): any;
    basicType(x: Ohm.Node): any;
    basicType_alt1(this: Ohm.Node, n$0: Ohm.Node, p$0: Ohm.Node): any;
    typeDefParent(x: Ohm.Node): any;
    typeDefParent_alt1(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node): any;
    typeDefParent_alt2(this: Ohm.Node): any;
    typeInitBlock(x: Ohm.Node): any;
    typeInitBlock_alt1(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node, _3: Ohm.Node): any;
    typeInitBlock_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeFields(x: Ohm.Node): any;
    typeFields_alt1(this: Ohm.Node, _1: Ohm.Node, fs$0: Ohm.Node, _3: Ohm.Node): any;
    typeFields_alt2(this: Ohm.Node): any;
    typeField(x: Ohm.Node): any;
    typeField_alt1(this: Ohm.Node, v$0: Ohm.Node, p$0: Ohm.Node): any;
    typeParameter(x: Ohm.Node): any;
    typeParameter_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, t$0: Ohm.Node): any;
    typeParameter_alt2(this: Ohm.Node, n$0: Ohm.Node): any;
    fieldVisibility(x: Ohm.Node): any;
    fieldVisibility_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    fieldVisibility_alt2(this: Ohm.Node): any;
    typeFieldName(x: Ohm.Node): any;
    typeFieldName_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    typeFieldName_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeInit(x: Ohm.Node): any;
    typeInit_alt1(this: Ohm.Node, s$0: Ohm.Node, _2: Ohm.Node): any;
    typeInit_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    typeInitCommand(x: Ohm.Node): any;
    typeInitCommand_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, c$0: Ohm.Node, _6: Ohm.Node, e$0: Ohm.Node, t$0: Ohm.Node): any;
    typeInitCommand_alt2(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, c$0: Ohm.Node, _6: Ohm.Node, b$0: Ohm.Node, t$0: Ohm.Node): any;
    typeInitCommand_alt3(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, s$0: Ohm.Node, c$0: Ohm.Node, _6: Ohm.Node, b$0: Ohm.Node, _8: Ohm.Node): any;
    defineDeclaration(x: Ohm.Node): any;
    defineDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, n$0: Ohm.Node, _5: Ohm.Node, e$0: Ohm.Node, _7: Ohm.Node): any;
    actionDeclaration(x: Ohm.Node): any;
    actionDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node, n$0: Ohm.Node, title$0: Ohm.Node, p$0: Ohm.Node, r$0: Ohm.Node, _9: Ohm.Node, b$0: Ohm.Node, c$0: Ohm.Node, _12: Ohm.Node): any;
    actionPredicate(x: Ohm.Node): any;
    actionPredicate_alt1(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node): any;
    actionPredicate_alt2(this: Ohm.Node): any;
    actionRank(x: Ohm.Node): any;
    actionRank_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node): any;
    actionRank_alt2(this: Ohm.Node): any;
    actionInit(x: Ohm.Node): any;
    actionInit_alt1(this: Ohm.Node, _1: Ohm.Node, cs$0: Ohm.Node): any;
    actionInit_alt2(this: Ohm.Node): any;
    whenDeclaration(x: Ohm.Node): any;
    whenDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, p$0: Ohm.Node, _5: Ohm.Node, b$0: Ohm.Node, _7: Ohm.Node): any;
    contextDeclaration(x: Ohm.Node): any;
    contextDeclaration_alt1(this: Ohm.Node, m$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, n$0: Ohm.Node, _5: Ohm.Node, xs$0: Ohm.Node, _7: Ohm.Node): any;
    contextItem(x: Ohm.Node): any;
    contextItem_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    contextItem_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    predicate(x: Ohm.Node): any;
    predicate_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    predicateBinary(x: Ohm.Node): any;
    predicateBinary_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    predicateBinary_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    predicateBinary_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    predicateAnd(x: Ohm.Node): any;
    predicateAnd_alt1(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    predicateAnd1(x: Ohm.Node): any;
    predicateAnd1_alt1(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    predicateAnd1_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    predicateOr(x: Ohm.Node): any;
    predicateOr_alt1(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    predicateOr1(x: Ohm.Node): any;
    predicateOr1_alt1(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    predicateOr1_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    predicateNot(x: Ohm.Node): any;
    predicateNot_alt1(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node): any;
    predicateNot_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    predicateConstrain(x: Ohm.Node): any;
    predicateConstrain_alt1(this: Ohm.Node, p$0: Ohm.Node, _2: Ohm.Node, c$0: Ohm.Node): any;
    predicateConstrain_alt2(this: Ohm.Node, _1: Ohm.Node, c$0: Ohm.Node): any;
    predicateConstrain_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    predicateConstrain_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    predicateConstrain_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    predicateConstrain_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    predicateType(x: Ohm.Node): any;
    predicateType_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, t$0: Ohm.Node): any;
    predicateLet(x: Ohm.Node): any;
    predicateLet_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, e$0: Ohm.Node): any;
    predicateSample(x: Ohm.Node): any;
    predicateSample_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, p$0: Ohm.Node): any;
    samplingPool(x: Ohm.Node): any;
    samplingPool_alt1(this: Ohm.Node, r$0: Ohm.Node): any;
    samplingPool_alt2(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, t$0: Ohm.Node): any;
    predicatePrimary(x: Ohm.Node): any;
    predicatePrimary_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    predicatePrimary_alt2(this: Ohm.Node, r$0: Ohm.Node): any;
    predicatePrimary_alt3(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node, _3: Ohm.Node): any;
    pattern(x: Ohm.Node): any;
    pattern_alt1(this: Ohm.Node, _1: Ohm.Node, c$0: Ohm.Node, _3: Ohm.Node): any;
    pattern_alt2(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node): any;
    pattern_alt3(this: Ohm.Node, n$0: Ohm.Node): any;
    pattern_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    pattern_alt5(this: Ohm.Node, l$0: Ohm.Node): any;
    pattern_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    patternComplex(x: Ohm.Node): any;
    patternComplex_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, t$0: Ohm.Node): any;
    patternName(x: Ohm.Node): any;
    patternName_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    patternName_alt2(this: Ohm.Node, n$0: Ohm.Node): any;
    statement(x: Ohm.Node): any;
    statement_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    statement_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    statement_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    statement_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    statement_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    statement_alt6(this: Ohm.Node, e$0: Ohm.Node): any;
    blockStatement(x: Ohm.Node): any;
    blockStatement_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    letStatement(x: Ohm.Node): any;
    letStatement_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, e$0: Ohm.Node): any;
    factStatement(x: Ohm.Node): any;
    factStatement_alt1(this: Ohm.Node, _1: Ohm.Node, s$0: Ohm.Node): any;
    forgetStatement(x: Ohm.Node): any;
    forgetStatement_alt1(this: Ohm.Node, _1: Ohm.Node, s$0: Ohm.Node): any;
    simulateStatement(x: Ohm.Node): any;
    simulateStatement_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, e$0: Ohm.Node, c$0: Ohm.Node, _5: Ohm.Node, g$0: Ohm.Node, s$0: Ohm.Node): any;
    simulateContext(x: Ohm.Node): any;
    simulateContext_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node): any;
    simulateContext_alt2(this: Ohm.Node): any;
    simulateGoal(x: Ohm.Node): any;
    simulateGoal_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node): any;
    simulateGoal_alt2(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node): any;
    simulateGoal_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    simulateGoal_alt4(this: Ohm.Node, p$0: Ohm.Node): any;
    signal(x: Ohm.Node): any;
    signal_alt1(this: Ohm.Node, _1: Ohm.Node, s$0: Ohm.Node, _3: Ohm.Node, b$0: Ohm.Node, _5: Ohm.Node): any;
    assertStatement(x: Ohm.Node): any;
    assertStatement_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node): any;
    expression(x: Ohm.Node): any;
    expression_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    expression_alt8(this: Ohm.Node, _1: Ohm.Node): any;
    searchExpression(x: Ohm.Node): any;
    searchExpression_alt1(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node): any;
    lazyExpression(x: Ohm.Node): any;
    lazyExpression_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node): any;
    forceExpression(x: Ohm.Node): any;
    forceExpression_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node): any;
    foreignExpression(x: Ohm.Node): any;
    foreignExpression_alt1(this: Ohm.Node, _1: Ohm.Node, ns$0: Ohm.Node, _3: Ohm.Node, xs$0: Ohm.Node, _5: Ohm.Node): any;
    continueWithExpression(x: Ohm.Node): any;
    continueWithExpression_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, e$0: Ohm.Node): any;
    expressionBlock(x: Ohm.Node): any;
    expressionBlock_alt1(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node, _3: Ohm.Node): any;
    assignExpression(x: Ohm.Node): any;
    assignExpression_alt1(this: Ohm.Node, l$0: Ohm.Node, op$0: Ohm.Node, r$0: Ohm.Node): any;
    pipeExpression(x: Ohm.Node): any;
    pipeExpression_alt1(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    pipeExpression_alt2(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    pipeExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    invokeMixfix(x: Ohm.Node): any;
    invokeMixfix_alt1(this: Ohm.Node, s$0: Ohm.Node, ps$0: Ohm.Node): any;
    invokeMixfix_alt2(this: Ohm.Node, ps$0: Ohm.Node): any;
    invokeMixfix_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression(x: Ohm.Node): any;
    invokeInfixExpression_alt1(this: Ohm.Node, l$0: Ohm.Node, _2: Ohm.Node, r$0: Ohm.Node): any;
    invokeInfixExpression_alt2(this: Ohm.Node, l$0: Ohm.Node, op$0: Ohm.Node, r$0: Ohm.Node): any;
    invokeInfixExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt8(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt9(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt10(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt11(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixExpression_alt12(this: Ohm.Node, _1: Ohm.Node): any;
    invokeInfixSequence(x: Ohm.Node): any;
    invokeInfixSequence_alt1(this: Ohm.Node, l$0: Ohm.Node, x$0: Ohm.Node, r$0: Ohm.Node): any;
    invokeInfixSequence_alt2(this: Ohm.Node, l$0: Ohm.Node, x$0: Ohm.Node, r$0: Ohm.Node): any;
    castExpression(x: Ohm.Node): any;
    castExpression_alt1(this: Ohm.Node, s$0: Ohm.Node, op$0: Ohm.Node, t$0: Ohm.Node): any;
    castExpression_alt2(this: Ohm.Node, s$0: Ohm.Node, _2: Ohm.Node, t$0: Ohm.Node): any;
    castExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    castType(x: Ohm.Node): any;
    castType_alt1(this: Ohm.Node, t$0: Ohm.Node): any;
    invokePrePost(x: Ohm.Node): any;
    invokePrePost_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    invokePrefix(x: Ohm.Node): any;
    invokePrefix_alt1(this: Ohm.Node, n$0: Ohm.Node, p$0: Ohm.Node): any;
    invokePrefix_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    invokePostfix(x: Ohm.Node): any;
    invokePostfix_alt1(this: Ohm.Node, s$0: Ohm.Node, n$0: Ohm.Node): any;
    invokePostfix_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    applyExpression(x: Ohm.Node): any;
    applyExpression_alt1(this: Ohm.Node, f$0: Ohm.Node, _2: Ohm.Node, xs$0: Ohm.Node, _4: Ohm.Node): any;
    applyExpression_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    memberExpression(x: Ohm.Node): any;
    memberExpression_alt1(this: Ohm.Node, o$0: Ohm.Node, _2: Ohm.Node, f$0: Ohm.Node): any;
    memberExpression_alt2(this: Ohm.Node, o$0: Ohm.Node, _2: Ohm.Node, p$0: Ohm.Node): any;
    memberExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    memberSelection(x: Ohm.Node): any;
    memberSelection_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    fieldSelection(x: Ohm.Node): any;
    fieldSelection_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, a$0: Ohm.Node): any;
    fieldSelection_alt2(this: Ohm.Node, n$0: Ohm.Node): any;
    primaryExpression(x: Ohm.Node): any;
    primaryExpression_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt8(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt9(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node): any;
    primaryExpression_alt10(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt11(this: Ohm.Node, _1: Ohm.Node): any;
    primaryExpression_alt12(this: Ohm.Node, n$0: Ohm.Node): any;
    primaryExpression_alt13(this: Ohm.Node, n$0: Ohm.Node): any;
    primaryExpression_alt14(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, _3: Ohm.Node): any;
    conditionExpression(x: Ohm.Node): any;
    conditionExpression_alt1(this: Ohm.Node, _1: Ohm.Node, cs$0: Ohm.Node, _3: Ohm.Node): any;
    conditionCase(x: Ohm.Node): any;
    conditionCase_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, b$0: Ohm.Node): any;
    conditionCase_alt2(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node): any;
    matchSearchExpression(x: Ohm.Node): any;
    matchSearchExpression_alt1(this: Ohm.Node, _1: Ohm.Node, c$0: Ohm.Node, _3: Ohm.Node): any;
    matchSearchCase(x: Ohm.Node): any;
    matchSearchCase_alt1(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node, b$0: Ohm.Node): any;
    matchSearchCase_alt2(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node): any;
    forExpression(x: Ohm.Node): any;
    forExpression_alt1(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node): any;
    forExprMap(x: Ohm.Node): any;
    forExprMap_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, e$0: Ohm.Node, r$0: Ohm.Node): any;
    forExprMap1(x: Ohm.Node): any;
    forExprMap1_alt1(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node): any;
    forExprMap1_alt2(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, b$0: Ohm.Node): any;
    forExprMap1_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    forExprDo(x: Ohm.Node): any;
    forExprDo_alt1(this: Ohm.Node, b$0: Ohm.Node): any;
    performExpression(x: Ohm.Node): any;
    performExpression_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, v$0: Ohm.Node, _5: Ohm.Node, xs$0: Ohm.Node, _7: Ohm.Node): any;
    newExpression(x: Ohm.Node): any;
    newExpression_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, fs$0: Ohm.Node): any;
    newFields(x: Ohm.Node): any;
    newFields_alt1(this: Ohm.Node, _1: Ohm.Node, fs$0: Ohm.Node, _3: Ohm.Node): any;
    newFields_alt2(this: Ohm.Node): any;
    listExpression(x: Ohm.Node): any;
    listExpression_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    recordExpression(x: Ohm.Node): any;
    recordExpression_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node): any;
    recordExpression_alt2(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    recordPair(x: Ohm.Node): any;
    recordPair_alt1(this: Ohm.Node, n$0: Ohm.Node, _2: Ohm.Node, v$0: Ohm.Node): any;
    recordField(x: Ohm.Node): any;
    recordField_alt1(this: Ohm.Node, n$0: Ohm.Node): any;
    recordField_alt2(this: Ohm.Node, t$0: Ohm.Node): any;
    recordField_alt3(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, _3: Ohm.Node): any;
    literalExpression(x: Ohm.Node): any;
    literalExpression_alt1(this: Ohm.Node, l$0: Ohm.Node): any;
    lambdaExpression(x: Ohm.Node): any;
    lambdaExpression_alt1(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, _3: Ohm.Node): any;
    lambdaExpression_alt2(this: Ohm.Node, _1: Ohm.Node, p$0: Ohm.Node, _3: Ohm.Node, e$0: Ohm.Node, _5: Ohm.Node): any;
    handleExpression(x: Ohm.Node): any;
    handleExpression_alt1(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node, _3: Ohm.Node, hs$0: Ohm.Node, _5: Ohm.Node): any;
    handlers(x: Ohm.Node): any;
    handlers_alt1(this: Ohm.Node, xs$0: Ohm.Node): any;
    one_handler(x: Ohm.Node): any;
    one_handler_alt1(this: Ohm.Node, _1: Ohm.Node, n$0: Ohm.Node, _3: Ohm.Node, v$0: Ohm.Node, _5: Ohm.Node, xs$0: Ohm.Node, _7: Ohm.Node, b$0: Ohm.Node): any;
    atomicExpression(x: Ohm.Node): any;
    atomicExpression_alt1(this: Ohm.Node, a$0: Ohm.Node): any;
    atomicExpression_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    atomicExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    atomicExpression_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    atomicExpression_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    atomicExpression_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    blockExpression(x: Ohm.Node): any;
    blockExpression_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    blockExpression_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    blockExpression_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    blockExpression_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    blockExpression_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    blockExpression_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    interpolateExpression(x: Ohm.Node): any;
    interpolateExpression_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    interpolateText(x: Ohm.Node): any;
    interpolateText_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    interpolateText_alt2(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    interpolatePart(x: Ohm.Node): any;
    interpolatePart_alt1(this: Ohm.Node, _1: Ohm.Node, c$0: Ohm.Node): any;
    interpolatePart_alt2(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node, _3: Ohm.Node): any;
    interpolatePart_alt3(this: Ohm.Node, c$0: Ohm.Node): any;
    interpolateStatic(x: Ohm.Node): any;
    interpolateStatic_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    dslExpression(x: Ohm.Node): any;
    dslExpression_alt1(this: Ohm.Node, _1: Ohm.Node, t$0: Ohm.Node, _3: Ohm.Node, x$0: Ohm.Node, _5: Ohm.Node): any;
    dslNodeSeq(x: Ohm.Node): any;
    dslNodeSeq_alt1(this: Ohm.Node, xs$0: Ohm.Node): any;
    dslNode(x: Ohm.Node): any;
    dslNode_alt1(this: Ohm.Node, s$0: Ohm.Node, o$0: Ohm.Node): any;
    dslNode_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    dslPrimary(x: Ohm.Node): any;
    dslPrimary_alt1(this: Ohm.Node, n$0: Ohm.Node): any;
    dslPrimary_alt2(this: Ohm.Node, x$0: Ohm.Node): any;
    dslPrimary_alt3(this: Ohm.Node, l$0: Ohm.Node): any;
    dslPrimary_alt4(this: Ohm.Node, x$0: Ohm.Node): any;
    dslPrimary_alt5(this: Ohm.Node, xs$0: Ohm.Node): any;
    dslPrimary_alt6(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node, _3: Ohm.Node): any;
    dslNodeList(x: Ohm.Node): any;
    dslNodeList_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    dslCrochet(x: Ohm.Node): any;
    dslCrochet_alt1(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node, _3: Ohm.Node): any;
    dslAttribute(x: Ohm.Node): any;
    dslAttribute_alt1(this: Ohm.Node, k$0: Ohm.Node, v$0: Ohm.Node): any;
    dslSignature(x: Ohm.Node): any;
    dslSignature_alt1(this: Ohm.Node, n$0: Ohm.Node, xs$0: Ohm.Node): any;
    dslSignatureComponent(x: Ohm.Node): any;
    dslSignatureComponent_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    dslSignatureComponent_alt2(this: Ohm.Node, n$0: Ohm.Node): any;
    literal(x: Ohm.Node): any;
    literal_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    literal_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    literal_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    literal_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    literal_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    nothing(x: Ohm.Node): any;
    nothing_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    boolean(x: Ohm.Node): any;
    boolean_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    boolean_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    text(x: Ohm.Node): any;
    text_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    integer(x: Ohm.Node): any;
    integer_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    float(x: Ohm.Node): any;
    float_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    string(x: Ohm.Node): any;
    string_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    hole(x: Ohm.Node): any;
    hole_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    atom(x: Ohm.Node): any;
    atom_alt1(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node): any;
    atom_alt2(this: Ohm.Node, x$0: Ohm.Node): any;
    name(x: Ohm.Node): any;
    name_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    keyword(x: Ohm.Node): any;
    keyword_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    attribute(x: Ohm.Node): any;
    attribute_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    infix_symbol(x: Ohm.Node): any;
    infix_symbol_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    not(x: Ohm.Node): any;
    not_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    and(x: Ohm.Node): any;
    and_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    or(x: Ohm.Node): any;
    or_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    as(x: Ohm.Node): any;
    as_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    namespace(x: Ohm.Node): any;
    namespace_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    named(x: Ohm.Node): any;
    named_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    logicSignature(x: Ohm.Node): any;
    logicSignature_alt1(this: Ohm.Node, s$0: Ohm.Node, kws$0: Ohm.Node): any;
    logicSignature_alt2(this: Ohm.Node, s$0: Ohm.Node, n$0: Ohm.Node): any;
    logicSignature_alt3(this: Ohm.Node, kws$0: Ohm.Node): any;
    signaturePair(x: Ohm.Node): any;
    signaturePair_alt1(this: Ohm.Node, kw$0: Ohm.Node, v$0: Ohm.Node): any;
    partialLogicSignature(x: Ohm.Node): any;
    partialLogicSignature_alt1(this: Ohm.Node, kws$0: Ohm.Node): any;
    partialLogicSignature_alt2(this: Ohm.Node, n$0: Ohm.Node): any;
    partialSignature(x: Ohm.Node): any;
    partialSignature_alt1(this: Ohm.Node, kws$0: Ohm.Node): any;
    partialSignature_alt2(this: Ohm.Node, op$0: Ohm.Node, r$0: Ohm.Node): any;
    partialSignature_alt3(this: Ohm.Node, n$0: Ohm.Node): any;
    partialSignature_alt4(this: Ohm.Node, n$0: Ohm.Node): any;
    signature(x: Ohm.Node): any;
    signature_alt1(this: Ohm.Node, l$0: Ohm.Node, op$0: Ohm.Node, r$0: Ohm.Node): any;
    signature_alt2(this: Ohm.Node, l$0: Ohm.Node, op$0: Ohm.Node, r$0: Ohm.Node): any;
    signature_alt3(this: Ohm.Node, s$0: Ohm.Node, kws$0: Ohm.Node): any;
    signature_alt4(this: Ohm.Node, s$0: Ohm.Node, n$0: Ohm.Node): any;
    signature_alt5(this: Ohm.Node, n$0: Ohm.Node, s$0: Ohm.Node): any;
    signature_alt6(this: Ohm.Node, kws$0: Ohm.Node): any;
    asParameter(x: Ohm.Node): any;
    asParameter_alt1(this: Ohm.Node, t$0: Ohm.Node): any;
    list0(x: Ohm.Node): any;
    list0_alt1(this: Ohm.Node, xs$0: Ohm.Node, _2: Ohm.Node): any;
    list1(x: Ohm.Node): any;
    list1_alt1(this: Ohm.Node, xs$0: Ohm.Node, _2: Ohm.Node): any;
    block(x: Ohm.Node): any;
    block_alt1(this: Ohm.Node, _1: Ohm.Node, xs$0: Ohm.Node, _3: Ohm.Node): any;
    statements(x: Ohm.Node): any;
    statements_alt1(this: Ohm.Node, h$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node): any;
    statements_alt2(this: Ohm.Node, h$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node, t$0: Ohm.Node): any;
    statements_alt3(this: Ohm.Node, x$0: Ohm.Node, _2: Ohm.Node): any;
    statements_alt4(this: Ohm.Node): any;
    statements1(x: Ohm.Node): any;
    statements1_alt1(this: Ohm.Node, h$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, t$0: Ohm.Node): any;
    statements1_alt2(this: Ohm.Node, h$0: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node, t$0: Ohm.Node): any;
    statements1_alt3(this: Ohm.Node, x$0: Ohm.Node, _2: Ohm.Node): any;
    eblock(x: Ohm.Node): any;
    eblock_alt1(this: Ohm.Node, _1: Ohm.Node, b$0: Ohm.Node, _3: Ohm.Node): any;
    eblock_alt2(this: Ohm.Node, _1: Ohm.Node, e$0: Ohm.Node, _3: Ohm.Node): any;
    s(x: Ohm.Node): any;
    s_alt1(this: Ohm.Node, _1: Ohm.Node, x$0: Ohm.Node): any;
    ws(x: Ohm.Node): any;
    ws_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    header(x: Ohm.Node): any;
    header_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node, _5: Ohm.Node): any;
    hs(x: Ohm.Node): any;
    hs_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    hs_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    nl(x: Ohm.Node): any;
    nl_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    nl_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    nl_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    line(x: Ohm.Node): any;
    line_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    comment(x: Ohm.Node): any;
    comment_alt1(this: Ohm.Node, _1: Ohm.Node, _3: Ohm.Node): any;
    space(x: Ohm.Node): any;
    space_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    doc(x: Ohm.Node): any;
    doc_alt1(this: Ohm.Node, xs$0: Ohm.Node): any;
    doc_line(x: Ohm.Node): any;
    doc_line_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, x$0: Ohm.Node, _5: Ohm.Node): any;
    semi(x: Ohm.Node): any;
    semi_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    atom_start(x: Ohm.Node): any;
    atom_start_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    atom_rest(x: Ohm.Node): any;
    atom_rest_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    atom_rest_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    atom_rest_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_atom(x: Ohm.Node): any;
    t_atom_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node): any;
    t_keyword(x: Ohm.Node): any;
    t_keyword_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node): any;
    t_attribute(x: Ohm.Node): any;
    t_attribute_alt1(this: Ohm.Node, _1: Ohm.Node, _3: Ohm.Node): any;
    name_start(x: Ohm.Node): any;
    name_start_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    name_start_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    name_rest(x: Ohm.Node): any;
    name_rest_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    name_rest_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    name_rest_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_name(x: Ohm.Node): any;
    t_name_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node): any;
    t_infix_symbol(x: Ohm.Node): any;
    t_infix_symbol_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    t_infix_symbol_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    t_infix_symbol_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_infix_symbol_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    t_any_infix(x: Ohm.Node): any;
    t_any_infix_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    t_any_infix_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    t_any_infix_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_relational_op(x: Ohm.Node): any;
    t_relational_op_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    t_relational_op_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    t_relational_op_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_relational_op_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    t_relational_op_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    t_relational_op_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op(x: Ohm.Node): any;
    t_arithmetic_op_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    t_arithmetic_op_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character(x: Ohm.Node): any;
    infix_character_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    infix_character_alt8(this: Ohm.Node, _1: Ohm.Node): any;
    dec_digit(x: Ohm.Node): any;
    dec_digit_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    dec_digit_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    hex_digit(x: Ohm.Node): any;
    hex_digit_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    hex_digit_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    hex_digit_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_integer(x: Ohm.Node): any;
    t_integer_alt1(this: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node): any;
    t_float(x: Ohm.Node): any;
    t_float_alt1(this: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node, _5: Ohm.Node): any;
    text_character(x: Ohm.Node): any;
    text_character_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node): any;
    text_character_alt2(this: Ohm.Node, _2: Ohm.Node): any;
    escape_sequence(x: Ohm.Node): any;
    escape_sequence_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node, _4: Ohm.Node, _5: Ohm.Node): any;
    escape_sequence_alt2(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node): any;
    escape_sequence_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    t_text(x: Ohm.Node): any;
    t_text_alt1(this: Ohm.Node, _1: Ohm.Node, _2: Ohm.Node, _3: Ohm.Node): any;
    kw(x: Ohm.Node): any;
    kw_alt1(this: Ohm.Node, x$0: Ohm.Node): any;
    relation_(x: Ohm.Node): any;
    relation__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    predicate_(x: Ohm.Node): any;
    predicate__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    when_(x: Ohm.Node): any;
    when__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    do_(x: Ohm.Node): any;
    do__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    command_(x: Ohm.Node): any;
    command__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    type_(x: Ohm.Node): any;
    type__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    enum_(x: Ohm.Node): any;
    enum__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    define_(x: Ohm.Node): any;
    define__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    singleton_(x: Ohm.Node): any;
    singleton__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    action_(x: Ohm.Node): any;
    action__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    let_(x: Ohm.Node): any;
    let__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    return_(x: Ohm.Node): any;
    return__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    fact_(x: Ohm.Node): any;
    fact__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    forget_(x: Ohm.Node): any;
    forget__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    new_(x: Ohm.Node): any;
    new__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    search_(x: Ohm.Node): any;
    search__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    if_(x: Ohm.Node): any;
    if__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    then_(x: Ohm.Node): any;
    then__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    else_(x: Ohm.Node): any;
    else__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    goto_(x: Ohm.Node): any;
    goto__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    call_(x: Ohm.Node): any;
    call__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    simulate_(x: Ohm.Node): any;
    simulate__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    match_(x: Ohm.Node): any;
    match__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    true_(x: Ohm.Node): any;
    true__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    false_(x: Ohm.Node): any;
    false__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    not_(x: Ohm.Node): any;
    not__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    and_(x: Ohm.Node): any;
    and__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    or_(x: Ohm.Node): any;
    or__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    is_(x: Ohm.Node): any;
    is__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    self_(x: Ohm.Node): any;
    self__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    as_(x: Ohm.Node): any;
    as__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    event_(x: Ohm.Node): any;
    event__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    quiescence_(x: Ohm.Node): any;
    quiescence__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    for_(x: Ohm.Node): any;
    for__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    until_(x: Ohm.Node): any;
    until__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    in_(x: Ohm.Node): any;
    in__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    foreign_(x: Ohm.Node): any;
    foreign__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    on_(x: Ohm.Node): any;
    on__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    always_(x: Ohm.Node): any;
    always__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    condition_(x: Ohm.Node): any;
    condition__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    end_(x: Ohm.Node): any;
    end__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    prelude_(x: Ohm.Node): any;
    prelude__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    with_(x: Ohm.Node): any;
    with__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    tags_(x: Ohm.Node): any;
    tags__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    rank_(x: Ohm.Node): any;
    rank__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    abstract_(x: Ohm.Node): any;
    abstract__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    lazy_(x: Ohm.Node): any;
    lazy__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    force_(x: Ohm.Node): any;
    force__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    context_(x: Ohm.Node): any;
    context__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    sample_(x: Ohm.Node): any;
    sample__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    of_(x: Ohm.Node): any;
    of__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    open_(x: Ohm.Node): any;
    open__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    local_(x: Ohm.Node): any;
    local__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    test_(x: Ohm.Node): any;
    test__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    assert_(x: Ohm.Node): any;
    assert__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    requires_(x: Ohm.Node): any;
    requires__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    ensures_(x: Ohm.Node): any;
    ensures__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    nothing_(x: Ohm.Node): any;
    nothing__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    effect_(x: Ohm.Node): any;
    effect__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    handle_(x: Ohm.Node): any;
    handle__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    continue_(x: Ohm.Node): any;
    continue__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    perform_(x: Ohm.Node): any;
    perform__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    dsl_(x: Ohm.Node): any;
    dsl__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    trait_(x: Ohm.Node): any;
    trait__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    implement_(x: Ohm.Node): any;
    implement__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    has_(x: Ohm.Node): any;
    has__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    global_(x: Ohm.Node): any;
    global__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    capability_(x: Ohm.Node): any;
    capability__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    protect_(x: Ohm.Node): any;
    protect__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    otherwise_(x: Ohm.Node): any;
    otherwise__alt1(this: Ohm.Node, _1: Ohm.Node): any;
    reserved(x: Ohm.Node): any;
    reserved_alt1(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt2(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt3(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt4(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt5(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt6(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt7(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt8(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt9(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt10(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt11(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt12(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt13(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt14(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt15(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt16(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt17(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt18(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt19(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt20(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt21(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt22(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt23(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt24(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt25(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt26(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt27(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt28(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt29(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt30(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt31(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt32(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt33(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt34(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt35(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt36(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt37(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt38(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt39(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt40(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt41(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt42(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt43(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt44(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt45(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt46(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt47(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt48(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt49(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt50(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt51(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt52(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt53(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt54(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt55(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt56(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt57(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt58(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt59(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt60(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt61(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt62(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt63(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt64(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt65(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt66(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt67(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt68(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt69(this: Ohm.Node, _1: Ohm.Node): any;
    reserved_alt70(this: Ohm.Node, _1: Ohm.Node): any;
};
export declare function toAst(result: Ohm.MatchResult): any;
export {};