/**
 * Aexol Language Parser
 *
 * Builds an Abstract Syntax Tree (AST) from a token stream.
 * Supports the full Aexol language grammar for capability definitions,
 * workflows, and agent structures.
 */
export interface ASTNode {
    type: string;
    location: {
        start: number;
        end: number;
        line: number;
        column: number;
    };
}
export interface Program extends ASTNode {
    type: "Program";
    body: (RoleDefinition | VisitorDefinition | WorkflowDefinition | AgentDefinition | TypeDefinition)[];
}
export interface VisitorDefinition extends ASTNode {
    type: "VisitorDefinition";
    name?: string;
    description?: string;
    capabilities: CapabilityNode[];
}
export interface CapabilityNode extends ASTNode {
    type: "Capability";
    verb?: "can" | "had" | "must" | "should" | "may" | "will" | "shall" | "cannot";
    action: string;
    description?: string;
    context?: string;
    nested?: CapabilityNode[];
    conditions?: ConditionNode[];
    metadata?: Record<string, unknown>;
}
export interface ConditionNode extends ASTNode {
    type: "Condition";
    expression: ExpressionNode;
}
export interface ExpressionNode extends ASTNode {
    type: "Expression";
    operator?: string;
    left?: ExpressionNode;
    right?: ExpressionNode;
    value?: string | number | boolean;
}
export interface RoleDefinition extends ASTNode {
    type: "RoleDefinition";
    name: string;
    description?: string;
    permissions: PermissionNode[];
    inherits?: string[];
}
export interface PermissionNode extends ASTNode {
    type: "Permission";
    resource: string;
    description?: string;
    actions: string[];
    conditions?: ConditionNode[];
}
export interface WorkflowDefinition extends ASTNode {
    type: "WorkflowDefinition";
    name: string;
    description?: string;
    steps: WorkflowStep[];
    initialState: string;
    finalStates: string[];
}
export interface WorkflowStep extends ASTNode {
    type: "WorkflowStep";
    name: string;
    description?: string;
    action: string;
    transitions: Transition[];
    parallel?: boolean;
}
export interface Transition extends ASTNode {
    type: "Transition";
    from: string;
    to: string;
    description?: string;
    condition?: ConditionNode;
    metadata?: Record<string, unknown>;
}
export interface AgentDefinition extends ASTNode {
    type: "AgentDefinition";
    name: string;
    description?: string;
    agentKind: "domain" | "builder";
    role: string;
    responsibilities: string[];
    workflow?: string;
    capabilities: CapabilityNode[];
    skills?: string[];
    model?: string;
    maxConcurrent?: number;
}
export interface TypeDefinition extends ASTNode {
    type: "TypeDefinition";
    name: string;
    description?: string;
    kind: "type" | "enum" | "interface";
    fields?: TypeField[];
    values?: string[];
    extends?: string[];
}
export interface TypeField extends ASTNode {
    type: "TypeField";
    name: string;
    description?: string;
    fieldType: string;
    required: boolean;
    default?: string | number | boolean;
}
export declare class Parser {
    private tokenizer;
    private currentToken;
    constructor(source: string);
    private advance;
    private check;
    private checkAny;
    private consume;
    private match;
    private consumeIdentifierOrKeyword;
    /**
     * Check if the current token is a keyword being used as an identifier in a
     * capability context. Many common English words (import, from, context, etc.)
     * are reserved keywords in the lexer but should be accepted as-is when they
     * appear as unquoted capability names (e.g. "can import catalog").
     */
    private isKeywordUsedAsIdentifier;
    private skipNewlines;
    private isAtEnd;
    /**
     * Check for and consume a description (PROMPT token with triple single-quotes) if present
     */
    private parseDescriptionIfPresent;
    private throwUnexpectedTopLevelToken;
    /**
     * Parse the entire program
     */
    parse(): Program;
    private parseVisitor;
    private parseCapability;
    private parseCondition;
    private parseExpression;
    private parseOrExpression;
    private parseAndExpression;
    private parseComparisonExpression;
    private parsePrimaryExpression;
    private parseRole;
    private parseWorkflow;
    private parseAgent;
    private parseTypeDefinition;
    /**
     * Parse string array: [item1, item2, item3]
     */
    private parseStringArray;
}
//# sourceMappingURL=parser.d.ts.map