type NodeType = 'TERM' | 'PHRASE' | 'FIELD' | 'AND' | 'OR' | 'NOT' | 'RANGE' | 'WILDCARD' | 'FUZZY' | 'GROUP';
interface QueryNode {
    type: NodeType;
}
interface TermNode extends QueryNode {
    type: 'TERM';
    value: string;
    boost?: number;
}
interface PhraseNode extends QueryNode {
    type: 'PHRASE';
    value: string;
    proximity?: number;
}
interface FieldNode extends QueryNode {
    type: 'FIELD';
    field: string;
    value: AnyQueryNode;
}
interface BooleanNode extends QueryNode {
    type: 'AND' | 'OR' | 'NOT';
    left: AnyQueryNode;
    right: AnyQueryNode;
}
interface RangeNode extends QueryNode {
    type: 'RANGE';
    field: string;
    lower: string;
    upper: string;
    includeLower: boolean;
    includeUpper: boolean;
}
interface WildcardNode extends QueryNode {
    type: 'WILDCARD';
    value: string;
}
interface FuzzyNode extends QueryNode {
    type: 'FUZZY';
    value: string;
    maxEdits: number;
}
interface GroupNode extends QueryNode {
    type: 'GROUP';
    value: AnyQueryNode;
}
type AnyQueryNode = TermNode | PhraseNode | FieldNode | BooleanNode | RangeNode | WildcardNode | FuzzyNode | GroupNode;
/**
 * Lucene query parser
 */
export declare class LuceneParser {
    private pos;
    private input;
    private tokens;
    constructor();
    /**
     * Parse a Lucene query string into an AST
     */
    parse(query: string): AnyQueryNode;
    /**
     * Tokenize the input string into tokens
     */
    private tokenize;
    /**
     * Parse the main query expression
     */
    private parseQuery;
    /**
     * Parse boolean operands (terms, phrases, fields, groups)
     */
    private parseBooleanOperand;
    /**
     * Parse range queries
     */
    private parseRange;
}
/**
 * Transformer for Lucene AST to MongoDB query
 * FIXED VERSION - proper MongoDB query structure
 */
export declare class LuceneToMongoTransformer {
    private defaultFields;
    constructor(defaultFields?: string[]);
    /**
     * Escape special characters for use in RegExp patterns
     */
    private escapeRegex;
    /**
     * Transform a Lucene AST node to a MongoDB query
     */
    transform(node: AnyQueryNode, searchFields?: string[]): any;
    /**
     * Transform a term to MongoDB query
     * FIXED: properly structured $or query for multiple fields
     */
    private transformTerm;
    /**
     * Transform a phrase to MongoDB query
     * FIXED: properly structured $or query for multiple fields
     */
    private transformPhrase;
    /**
     * Transform a field query to MongoDB query
     */
    private transformField;
    /**
     * Extract a term from a boolean query (simplification)
     */
    private extractTermFromBooleanQuery;
    /**
     * Transform AND operator to MongoDB query
     * FIXED: $and must be an array
     */
    private transformAnd;
    /**
     * Transform OR operator to MongoDB query
     * FIXED: $or must be an array
     */
    private transformOr;
    /**
     * Transform NOT operator to MongoDB query
     * FIXED: $and must be an array and $not usage
     */
    private transformNot;
    /**
     * Transform range query to MongoDB query
     */
    private transformRange;
    /**
     * Transform wildcard query to MongoDB query
     * FIXED: properly structured for multiple fields
     */
    private transformWildcard;
    /**
     * Transform fuzzy query to MongoDB query
     * FIXED: properly structured for multiple fields
     */
    private transformFuzzy;
    /**
     * Convert Lucene wildcards to MongoDB regex patterns
     */
    luceneWildcardToRegex(wildcardPattern: string): string;
    /**
     * Create a simplified fuzzy search regex
     */
    private createFuzzyRegex;
    /**
     * Parse string values to appropriate types (numbers, dates, etc.)
     */
    private parseValue;
}
/**
 * Main adapter class
 */
export declare class SmartdataLuceneAdapter {
    private parser;
    private transformer;
    private defaultSearchFields;
    /**
     * @param defaultSearchFields - Optional array of field names to search across when no field is specified
     */
    constructor(defaultSearchFields?: string[]);
    /**
     * Convert a Lucene query string to a MongoDB query object
     * @param luceneQuery - The Lucene query string to convert
     * @param searchFields - Optional array of field names to search across (overrides defaultSearchFields)
     */
    convert(luceneQuery: string, searchFields?: string[]): any;
    /**
     * Helper method to transform the AST with field information
     */
    private transformWithFields;
}
export {};