/**
 * Create a new SPARQL Pattern Matcher
 * @param {Object} store - Store with match() method
 * @param {Object.<string, string>} [prefixes] - Namespace prefixes
 * @returns {SPARQLPatternMatcher} Pattern matcher instance
 */
export function createSPARQLPatternMatcher(store: any, prefixes?: {
    [x: string]: string;
}): SPARQLPatternMatcher;
/**
 * SPARQL Pattern Matcher
 * Converts SPARQL WHERE patterns to efficient triple store queries
 */
export class SPARQLPatternMatcher {
    /**
     * Create a new SPARQL Pattern Matcher
     * @param {Object} store - OxigraphStore or compatible store with match/getQuads method
     * @param {Object.<string, string>} [prefixes] - Additional namespace prefixes
     */
    constructor(store: any, prefixes?: {
        [x: string]: string;
    });
    store: any;
    prefixes: {
        rdf: string;
        rdfs: string;
        xsd: string;
        owl: string;
        foaf: string;
        dc: string;
        dcterms: string;
        schema: string;
        ex: string;
    };
    _queryCache: Map<any, any>;
    /**
     * Match a triple pattern against the store
     * @param {string|Object|null} subject - Subject pattern (variable, URI, or null for any)
     * @param {string|Object|null} predicate - Predicate pattern
     * @param {string|Object|null} object - Object pattern
     * @param {Array<function>} [filters] - Optional FILTER functions
     * @returns {Promise<Array<Object>>} Matching bindings
     */
    matchPattern(subject: string | any | null, predicate: string | any | null, object: string | any | null, filters?: Array<Function>): Promise<Array<any>>;
    /**
     * Execute a full SPARQL SELECT query
     * @param {string} sparqlQuery - SPARQL SELECT query string
     * @returns {Promise<Array<Object>>} Query results as binding objects
     */
    executeQuery(sparqlQuery: string): Promise<Array<any>>;
    /**
     * Compile a triple pattern to BEAM-compatible pattern string
     * @param {string|Object|null} subject - Subject pattern
     * @param {string|Object|null} predicate - Predicate pattern
     * @param {string|Object|null} object - Object pattern
     * @returns {string} BEAM pattern representation
     */
    compileToBeamPattern(subject: string | any | null, predicate: string | any | null, object: string | any | null): string;
    /**
     * Parse a pattern term for matching
     * @param {string|Object|null} term - Pattern term
     * @returns {Object} Parsed term
     * @private
     */
    private _parsePatternTerm;
    /**
     * Convert parsed term to store-compatible term
     * @param {Object} parsed - Parsed term
     * @returns {Object|null} Store term or null
     * @private
     */
    private _toStoreTerm;
    /**
     * Compile a term to BEAM pattern representation
     * @param {string|Object|null} term - Term to compile
     * @returns {string} BEAM pattern string
     * @private
     */
    private _compileTermToBeam;
    /**
     * Parse a SPARQL query
     * @param {string} query - SPARQL query string
     * @returns {Object|null} Parsed query or null
     * @private
     */
    private _parseQuery;
    /**
     * Join two sets of bindings on common variables
     * @param {Array<Object>} left - Left bindings
     * @param {Array<Object>} right - Right bindings
     * @returns {Array<Object>} Joined bindings
     * @private
     */
    private _joinBindings;
    /**
     * Clear the query cache
     */
    clearCache(): void;
    /**
     * Get cache statistics
     * @returns {{size: number, maxSize: number}}
     */
    getCacheStats(): {
        size: number;
        maxSize: number;
    };
    /**
     * Compile a full SPARQL query to BEAM list comprehension syntax
     * @param {string} sparqlQuery - SPARQL SELECT or ASK query
     * @returns {string} BEAM list comprehension code
     */
    compileQueryToBeam(sparqlQuery: string): string;
    /**
     * Compile a pattern term to BEAM syntax
     * @param {string} term - Pattern term
     * @param {string} defaultVar - Default variable name
     * @returns {string} BEAM term
     * @private
     */
    private _compilePatternTermToBeam;
    /**
     * Compile a FILTER expression to BEAM guard
     * @param {string} filterExpr - FILTER expression
     * @param {Map<string, Array<string>>} varMap - Variable to position mapping
     * @returns {string|null} BEAM guard or null
     * @private
     */
    private _compileFilterToBeam;
    /**
     * Get BEAM variable name from SPARQL variable
     * @param {string} sparqlVar - SPARQL variable name (without ?)
     * @param {Map<string, Array<string>>} varMap - Variable mapping
     * @returns {string} BEAM variable name
     * @private
     */
    private _getBeamVarName;
    /**
     * Capitalize a variable name for BEAM
     * @param {string} varName - Variable name
     * @returns {string} Capitalized name
     * @private
     */
    private _capitalizeVar;
}
export default SPARQLPatternMatcher;