/**
 * Global Rule Language (GRL) Specification
 *
 * Human-readable DSL for compliance rules with formal grammar
 * and parser (Enhancement #14).
 */
/**
 * GRL Token types
 */
export declare enum GRLTokenType {
    RULE = "RULE",
    WHEN = "WHEN",
    THEN = "THEN",
    AND = "AND",
    OR = "OR",
    NOT = "NOT",
    IF = "IF",
    ELSE = "ELSE",
    IN = "IN",
    BETWEEN = "BETWEEN",
    MATCHES = "MATCHES",
    EXISTS = "EXISTS",
    ALLOW = "ALLOW",
    DENY = "DENY",
    FLAG = "FLAG",
    WITH = "WITH",
    SEVERITY = "SEVERITY",
    CODE = "CODE",
    MESSAGE = "MESSAGE",
    APPLIES_TO = "APPLIES_TO",
    JURISDICTION = "JURISDICTION",
    EFFECTIVE = "EFFECTIVE",
    EXPIRES = "EXPIRES",
    TAGS = "TAGS",
    STRING = "STRING",
    NUMBER = "NUMBER",
    BOOLEAN = "BOOLEAN",
    NULL = "NULL",
    REGEX = "REGEX",
    EQ = "EQ",// ==
    NE = "NE",// !=
    LT = "LT",// <
    LE = "LE",// <=
    GT = "GT",// >
    GE = "GE",// >=
    CONTAINS = "CONTAINS",
    STARTS_WITH = "STARTS_WITH",
    ENDS_WITH = "ENDS_WITH",
    LPAREN = "LPAREN",// (
    RPAREN = "RPAREN",// )
    LBRACKET = "LBRACKET",// [
    RBRACKET = "RBRACKET",// ]
    COMMA = "COMMA",// ,
    DOT = "DOT",// .
    COLON = "COLON",// :
    IDENTIFIER = "IDENTIFIER",
    FIELD_PATH = "FIELD_PATH",
    NEWLINE = "NEWLINE",
    EOF = "EOF",
    INVALID = "INVALID"
}
/**
 * GRL Token
 */
export interface GRLToken {
    type: GRLTokenType;
    value: string;
    line: number;
    column: number;
}
/**
 * GRL AST Node types
 */
export type GRLNode = GRLRuleNode | GRLConditionNode | GRLConsequenceNode | GRLFieldNode | GRLLiteralNode | GRLArrayNode;
/**
 * Rule node
 */
export interface GRLRuleNode {
    type: 'rule';
    name: string;
    description?: string;
    condition: GRLConditionNode;
    consequence: GRLConsequenceNode;
    metadata: {
        appliesTo?: {
            entityType?: string;
            eventType?: string;
        };
        jurisdiction?: string;
        effectiveFrom?: string;
        effectiveTo?: string;
        severity?: string;
        tags?: string[];
    };
}
/**
 * Condition nodes
 */
export type GRLConditionNode = GRLAndCondition | GRLOrCondition | GRLNotCondition | GRLCompareCondition;
export interface GRLAndCondition {
    type: 'and';
    conditions: GRLConditionNode[];
}
export interface GRLOrCondition {
    type: 'or';
    conditions: GRLConditionNode[];
}
export interface GRLNotCondition {
    type: 'not';
    condition: GRLConditionNode;
}
export interface GRLCompareCondition {
    type: 'compare';
    field: string;
    operator: string;
    value: GRLLiteralNode | GRLArrayNode | GRLFieldNode;
}
/**
 * Consequence node
 */
export interface GRLConsequenceNode {
    type: 'consequence';
    decision: 'ALLOW' | 'DENY' | 'FLAG';
    code: string;
    message: string;
    remediation?: string;
}
/**
 * Field reference node
 */
export interface GRLFieldNode {
    type: 'field';
    path: string;
}
/**
 * Literal value node
 */
export interface GRLLiteralNode {
    type: 'literal';
    valueType: 'string' | 'number' | 'boolean' | 'null' | 'regex';
    value: unknown;
}
/**
 * Array node
 */
export interface GRLArrayNode {
    type: 'array';
    elements: (GRLLiteralNode | GRLFieldNode)[];
}
/**
 * Parse result
 */
export interface GRLParseResult {
    success: boolean;
    rules: GRLRuleNode[];
    errors: GRLParseError[];
}
/**
 * Parse error
 */
export interface GRLParseError {
    message: string;
    line: number;
    column: number;
    severity: 'ERROR' | 'WARNING';
}
/**
 * GRL Lexer
 */
export declare class GRLLexer {
    private source;
    private pos;
    private line;
    private column;
    private tokens;
    constructor(source: string);
    tokenize(): GRLToken[];
    private skipWhitespaceAndComments;
    private nextToken;
    private readString;
    private readNumber;
    private readRegex;
    private readOperator;
    private readIdentifier;
    private advance;
    private isDigit;
    private isAlpha;
    private isAlphaNumeric;
}
/**
 * GRL Parser
 */
export declare class GRLParser {
    private tokens;
    private pos;
    private errors;
    parse(source: string): GRLParseResult;
    private parseRule;
    private parseCondition;
    private parseOr;
    private parseAnd;
    private parseUnary;
    private parsePrimary;
    private parseComparison;
    private parseFieldPath;
    private parseOperator;
    private parseValue;
    private parseArray;
    private parseLiteral;
    private parseConsequence;
    private match;
    private check;
    private advance;
    private current;
    private previous;
    private isAtEnd;
    private consume;
    private synchronize;
}
/**
 * Parse GRL source code
 */
export declare function parseGRL(source: string): GRLParseResult;
/**
 * Convert GRL AST to ArkaRule
 */
export declare function grlToArkaRule(grlRule: GRLRuleNode): import('@arka/types').ArkaRule;
/**
 * Example GRL syntax
 */
export declare const GRL_EXAMPLE = "\n// Example ARKA Global Rule Language\n\nRULE \"High APR Consumer Loan Check\"\nAPPLIES_TO \"consumer_loan\"\nJURISDICTION \"US\"\nSEVERITY HIGH\nTAGS [\"lending\", \"consumer-protection\", \"apr\"]\n\nWHEN\n  loan.apr > 36.0\n  AND borrower.state IN [\"CA\", \"NY\", \"TX\"]\n  AND loan.amount >= 1000\n\nTHEN\n  DENY WITH\n  CODE \"APR_EXCEEDED_36\"\n  MESSAGE \"APR exceeds 36% maximum for consumer loans in this state\"\n\n// Another rule example\nRULE \"Large Transaction Flagging\"\nAPPLIES_TO \"transaction\"\nSEVERITY MEDIUM\n\nWHEN\n  transaction.amount > 10000\n  OR (transaction.type == \"international\" AND transaction.amount > 5000)\n\nTHEN\n  FLAG WITH\n  CODE \"LARGE_TXN_REVIEW\"\n  MESSAGE \"Transaction requires manual review due to amount\"\n";
//# sourceMappingURL=grlSpec.d.ts.map