import { SourceRange } from "./source-position";
export { SourceRange } from "./source-position";
export declare enum SyntaxKind {
    File = 0,
    Keyword = 1,
    Namespace = 2,
    AssignmentStatement = 3,
    Behavior = 4,
    Binding = 5,
    Compound = 6,
    ComponentDefinition = 7,
    DeferStatement = 8,
    EmptyStatement = 9,
    EnumDefinition = 10,
    Event = 11,
    ExpressionStatement = 12,
    ExternDeclaration = 13,
    FunctionDefinition = 14,
    ForeignFunctionDeclaration = 15,
    GuardStatement = 16,
    IfStatement = 17,
    ImportStatement = 18,
    Instance = 19,
    IntDefinition = 20,
    InterfaceDefinition = 21,
    InvariantStatement = 22,
    OnStatement = 23,
    Port = 24,
    ReturnStatement = 25,
    System = 26,
    VariableDefinition = 27,
    BinaryExpression = 28,
    BindingCompoundName = 29,
    BooleanLiteral = 30,
    CallExpression = 31,
    CompoundName = 32,
    DollarLiteral = 33,
    Identifier = 34,
    NumericLiteral = 35,
    ParenthesizedExpression = 36,
    Reply = 37,
    UnaryOperatorExpression = 38,
    CallArguments = 39,
    DeferArguments = 40,
    EventParameter = 41,
    FunctionParameter = 42,
    OnParameter = 43,
    OnTrigger = 44,
    OnTriggerParameters = 45,
    TypeReference = 46,
    ERROR = 47
}
export interface AstNode<TKind extends SyntaxKind> {
    kind: TKind;
    position: SourceRange;
    parent?: AnyAstNode;
    errors?: Error[];
}
export interface Error extends AstNode<SyntaxKind.ERROR> {
    text: string;
}
export interface Keyword<TKind extends string> extends AstNode<SyntaxKind.Keyword> {
    text: TKind;
}
export type AnyAstNode = AstNode<SyntaxKind>;
export interface File extends AstNode<SyntaxKind.File> {
    fileName?: string;
    statements: RootStatement[];
}
export type RootStatement = Namespace | ExternDeclaration | TypeDefinition | ImportStatement | InterfaceDefinition | ComponentDefinition | FunctionDefinition | ForeignFunctionDeclaration | Statement;
export type Statement = DeclarativeStatement | ImperativeStatement;
export interface Compound extends AstNode<SyntaxKind.Compound> {
    blocking?: Keyword<"blocking">;
    statements: Statement[];
}
export interface ImportStatement extends AstNode<SyntaxKind.ImportStatement> {
    fileName: string;
}
export type TypeDefinition = EnumDefinition | IntDefinition | ExternDeclaration;
export interface ExternDeclaration extends AstNode<SyntaxKind.ExternDeclaration> {
    name: Identifier;
    value: DollarsLiteral;
}
export interface EnumDefinition extends AstNode<SyntaxKind.EnumDefinition> {
    name: Identifier;
    members: Identifier[];
}
export interface IntDefinition extends AstNode<SyntaxKind.IntDefinition> {
    name: Identifier;
    from: number;
    to: number;
}
export type NamespaceStatement = TypeDefinition | Namespace | InterfaceDefinition | ComponentDefinition | FunctionDefinition | ForeignFunctionDeclaration;
export interface Namespace extends AstNode<SyntaxKind.Namespace> {
    name: Name;
    statements: NamespaceStatement[];
}
export interface InterfaceDefinition extends AstNode<SyntaxKind.InterfaceDefinition> {
    name: Identifier;
    body: Array<TypeDefinition | Event>;
    behavior?: Behavior;
}
export type EventDirection = Keyword<"in"> | Keyword<"out">;
export interface EventParameter extends AstNode<SyntaxKind.EventParameter> {
    direction?: ParameterDirection;
    type: TypeReference;
    name: Name;
}
export interface Event extends AstNode<SyntaxKind.Event> {
    direction: EventDirection;
    type: TypeReference;
    name: Identifier;
    parameters: EventParameter[];
}
export interface ComponentDefinition extends AstNode<SyntaxKind.ComponentDefinition> {
    name: Identifier;
    ports: Port[];
    body?: Behavior | System;
}
export interface System extends AstNode<SyntaxKind.System> {
    instancesAndBindings: Array<Instance | Binding>;
}
export interface Instance extends AstNode<SyntaxKind.Instance> {
    type: TypeReference;
    name: Identifier;
}
export interface Binding extends AstNode<SyntaxKind.Binding> {
    left: BindingExpression;
    right: BindingExpression;
}
export type BindingExpression = Identifier | BindingCompoundName | Keyword<"*"> | Error;
export interface BindingCompoundName extends AstNode<SyntaxKind.BindingCompoundName> {
    compound: BindingExpression;
    name: Keyword<"*"> | Identifier;
}
export type PortDirection = Keyword<"provides"> | Keyword<"requires">;
export interface Port extends AstNode<SyntaxKind.Port> {
    direction: PortDirection;
    qualifiers: Array<Keyword<"external"> | Keyword<"injected"> | Keyword<"blocking">>;
    type: TypeReference;
    name: Identifier;
}
export type BehaviorStatement = Port | FunctionDefinition | InvariantStatement | VariableDefinition | DeclarativeStatement | TypeDefinition;
export interface Behavior extends AstNode<SyntaxKind.Behavior> {
    name?: Identifier;
    statements: BehaviorStatement[];
}
export interface FunctionDefinition extends AstNode<SyntaxKind.FunctionDefinition> {
    returnType: TypeReference;
    name: Identifier;
    parameters: FunctionParameter[];
    body: Compound | Expression;
}
export interface ForeignFunctionDeclaration extends AstNode<SyntaxKind.ForeignFunctionDeclaration> {
    returnType: TypeReference;
    name: Identifier;
    parameters: FunctionParameter[];
}
export type ParameterDirection = Keyword<"in"> | Keyword<"out"> | Keyword<"inout">;
export interface FunctionParameter extends AstNode<SyntaxKind.FunctionParameter> {
    direction?: ParameterDirection;
    type: TypeReference;
    name: Identifier;
}
export type DeclarativeStatement = OnStatement | GuardStatement | InvariantStatement | Compound;
export interface OnParameter extends AstNode<SyntaxKind.OnParameter> {
    name: Identifier;
    assignment?: Identifier;
}
export interface OnTriggerParameters extends AstNode<SyntaxKind.OnTriggerParameters> {
    parameters: OnParameter[];
}
export type OnTrigger = Keyword<"optional"> | Keyword<"inevitable"> | OnPortTrigger | Error;
export interface OnPortTrigger extends AstNode<SyntaxKind.OnTrigger> {
    name: Name;
    parameterList?: OnTriggerParameters;
}
export interface OnStatement extends AstNode<SyntaxKind.OnStatement> {
    blocking?: Keyword<"blocking">;
    triggers: OnTrigger[];
    body: Statement;
}
export interface GuardStatement extends AstNode<SyntaxKind.GuardStatement> {
    blocking?: Keyword<"blocking">;
    condition: Keyword<"otherwise"> | Expression | Error;
    statement: Statement;
}
export interface InvariantStatement extends AstNode<SyntaxKind.InvariantStatement> {
    expression: Expression;
}
export type ImperativeStatement = IfStatement | ReturnStatement | VariableDefinition | AssignmentStatement | DeferStatement | EmptyStatement | ExpressionStatement | Compound;
export interface AssignmentStatement extends AstNode<SyntaxKind.AssignmentStatement> {
    left: Name;
    right: Expression;
}
export interface DeferArguments extends AstNode<SyntaxKind.DeferArguments> {
    arguments: Expression[];
}
export interface DeferStatement extends AstNode<SyntaxKind.DeferStatement> {
    arguments?: DeferArguments;
    statement: ImperativeStatement;
}
export interface EmptyStatement extends AstNode<SyntaxKind.EmptyStatement> {
}
export interface ExpressionStatement extends AstNode<SyntaxKind.ExpressionStatement> {
    expression: Expression;
}
export interface IfStatement extends AstNode<SyntaxKind.IfStatement> {
    condition: Expression;
    statement: ImperativeStatement;
    else?: ImperativeStatement;
}
export interface ReturnStatement extends AstNode<SyntaxKind.ReturnStatement> {
    returnValue?: Expression;
}
export interface VariableDefinition extends AstNode<SyntaxKind.VariableDefinition> {
    type: TypeReference;
    name: Identifier;
    initializer?: Expression;
}
export type Expression = UnaryExpression | BinaryExpression | Error;
export type UnaryExpression = ParenthesizedExpression | BindingExpression | CallExpression | DollarsLiteral | Name | BooleanLiteral | NumericLiteral | Reply | UnaryOperatorExpression | Keyword<"illegal"> | Keyword<"otherwise">;
export type BinaryOperator = Keyword<"&&"> | Keyword<"||"> | Keyword<"=="> | Keyword<"!="> | Keyword<"<="> | Keyword<"<"> | Keyword<">="> | Keyword<">"> | Keyword<"+"> | Keyword<"-"> | Keyword<"=>">;
export interface BinaryExpression extends AstNode<SyntaxKind.BinaryExpression> {
    left: Expression;
    operator: BinaryOperator;
    right: Expression;
}
export interface ParenthesizedExpression extends AstNode<SyntaxKind.ParenthesizedExpression> {
    expression: Expression;
}
export interface DollarsLiteral extends AstNode<SyntaxKind.DollarLiteral> {
    text: string;
}
export interface Identifier extends AstNode<SyntaxKind.Identifier> {
    text: string;
}
export interface CallArguments extends AstNode<SyntaxKind.CallArguments> {
    arguments: Expression[];
}
export interface CallExpression extends AstNode<SyntaxKind.CallExpression> {
    expression: Expression;
    arguments: CallArguments;
}
export interface CompoundName extends AstNode<SyntaxKind.CompoundName> {
    compound?: CompoundName | Identifier;
    name: Identifier;
}
export interface BooleanLiteral extends AstNode<SyntaxKind.BooleanLiteral> {
    value: boolean;
}
export interface NumericLiteral extends AstNode<SyntaxKind.NumericLiteral> {
    value: number;
}
export interface Reply extends AstNode<SyntaxKind.Reply> {
    port?: Identifier;
    value?: Expression;
}
export type UnaryOperator = Keyword<"!"> | Keyword<"-">;
export interface UnaryOperatorExpression extends AstNode<SyntaxKind.UnaryOperatorExpression> {
    operator: UnaryOperator;
    expression: Expression;
}
export type Name = Identifier | CompoundName;
export interface TypeReference extends AstNode<SyntaxKind.TypeReference> {
    typeName: Name;
}