import * as P from 'parsimmon';
import { TemplateName } from './util';
export declare type NodeTypes = {
    'Attribute': Attribute;
    'Call': Call;
    'DelCall': DelCall;
    'Interpolation': Interpolation;
    'LetStatement': LetStatement;
    'Literal': Literal;
    'OtherCmd': OtherCmd;
    'MapLiteral': MapLiteral;
    'MapItem': MapItem;
    'StringLiteral': StringLiteral;
    'NumberLiteral': NumberLiteral;
    'BooleanLiteral': BooleanLiteral;
    'OtherExpression': OtherExpression;
    'Param': Param;
    'ParamDeclaration': ParamDeclaration;
    'Program': Program;
    'Reference': Reference;
    'Ternary': Ternary;
    'FunctionCall': FunctionCall;
    'SoyDoc': SoyDoc;
    'Template': Template;
    'DelTemplate': DelTemplate;
    'Other': OtherCmd;
};
export declare type NodeType = keyof NodeTypes;
export declare type Cmd = Call | Interpolation | LetStatement | Literal | OtherCmd;
export declare type Body = Array<Node>;
export declare type Expression = MapLiteral | StringLiteral | NumberLiteral | BooleanLiteral | OtherExpression | Reference | Ternary | FunctionCall;
export interface Node {
    body?: Body;
    mark: Mark;
    type: NodeType;
}
export interface Mark {
    start: P.Index;
    end: P.Index;
}
export interface Program extends Node {
    body: Array<Template | DelTemplate>;
    namespace: string;
    type: 'Program';
}
export declare function Program(mark: Mark, namespace: string, body: Array<Template>): Program;
export interface Attribute extends Node {
    name: string;
    value: string;
    type: 'Attribute';
}
export declare function Attribute(mark: Mark, name: string, value: string): Attribute;
export interface OtherExpression extends Node {
    type: 'OtherExpression';
    content: string;
}
export declare function OtherExpression(mark: Mark, content: string): OtherExpression;
export interface FunctionCall extends Node {
    type: 'FunctionCall';
    name: string;
    body: Array<Expression>;
}
export declare function FunctionCall(mark: Mark, name: string, body: Array<Expression>): FunctionCall;
export interface Reference extends Node {
    type: 'Reference';
    name: string;
}
export declare function Reference(mark: Mark, name: string): Reference;
export interface Ternary extends Node {
    type: 'Ternary';
    condition: Expression;
    left: Expression;
    right: Expression;
}
export declare function Ternary(mark: Mark, condition: Expression, left: Expression, right: Expression): Ternary;
export interface MapLiteral extends Node {
    items: Array<MapItem>;
    type: 'MapLiteral';
}
export declare function MapLiteral(mark: Mark, items: Array<MapItem>): MapLiteral;
export interface MapItem extends Node {
    type: 'MapItem';
    key: StringLiteral;
    value: Expression;
}
export declare function MapItem(mark: Mark, key: StringLiteral, value: Expression): MapItem;
export interface BooleanLiteral extends Node {
    type: 'BooleanLiteral';
    value: boolean;
}
export declare function BooleanLiteral(mark: Mark, value: boolean): BooleanLiteral;
export interface StringLiteral extends Node {
    type: 'StringLiteral';
    value: string;
}
export declare function StringLiteral(mark: Mark, value: string): StringLiteral;
export interface NumberLiteral extends Node {
    type: 'NumberLiteral';
    value: number;
}
export declare function NumberLiteral(mark: Mark, value: number): NumberLiteral;
export interface SoyDoc extends Node {
    about: string;
    params: Array<ParamDeclaration>;
    type: 'SoyDoc';
}
export declare function SoyDoc(mark: Mark, about: string, params: Array<ParamDeclaration>): SoyDoc;
export interface Template extends Node {
    attributes: Array<Attribute>;
    body: Body;
    doc: SoyDoc | null;
    id: TemplateName;
    params: Array<ParamDeclaration>;
    type: 'Template';
}
export declare function Template(mark: Mark, doc: SoyDoc | null, id: TemplateName, attributes: Array<Attribute>, params?: Array<ParamDeclaration>, body?: Body): Template;
export interface DelTemplate extends Node {
    body: Body;
    doc: SoyDoc | null;
    id: TemplateName;
    params: Array<ParamDeclaration>;
    variant: Interpolation | null;
    type: 'DelTemplate';
}
export declare function DelTemplate(mark: Mark, doc: SoyDoc | null, id: TemplateName, variant: Interpolation | null, params?: Array<ParamDeclaration>, body?: Body): DelTemplate;
export interface Interpolation extends Node {
    content: string;
    type: 'Interpolation';
}
export declare function Interpolation(mark: Mark, content: string): Interpolation;
export interface Literal extends Node {
    content: string;
    type: 'Literal';
}
export declare function Literal(mark: Mark, content: string): Literal;
export interface Param extends Node {
    body: Body;
    name: string;
    type: 'Param';
}
export declare function Param(mark: Mark, name: string, body: Body): Param;
export interface ParamDeclaration extends Node {
    name: string;
    paramType: string;
    required: boolean;
    type: 'ParamDeclaration';
}
export declare function ParamDeclaration(mark: Mark, required: boolean, name: string, paramType: string): ParamDeclaration;
export interface LetStatement extends Node {
    type: 'LetStatement';
    body: Body;
    name: string;
}
export declare function LetStatement(mark: Mark, name: string, body: Body): LetStatement;
export interface Call extends Node {
    body: Array<Param>;
    id: TemplateName;
    type: 'Call';
}
export declare function Call(mark: Mark, id: TemplateName, body?: Array<Param>): Call;
export interface DelCall extends Node {
    body: Array<Param>;
    id: TemplateName;
    attributes: Array<Attribute>;
    type: 'DelCall';
}
export declare function DelCall(mark: Mark, id: TemplateName, attributes: Array<Attribute>, body?: Array<Param>): DelCall;
export interface OtherCmd extends Node {
    name: string;
    body: Body;
}
export declare function OtherCmd(mark: Mark, name: string, body?: Body): OtherCmd;