import { Concept } from "../concept/Concept";
/**
 * Contains a mapping of variables to concepts.
 */
export interface ConceptMap {
    /**
     * Produces an iterator over all variables in this <code>ConceptMap</code>.
     *
     * ### Examples
     *
     * ```ts
     * conceptMap.variables()
     * ```
     */
    variables(): IterableIterator<string>;
    /**
     * Produces an iterator over all concepts in this <code>ConceptMap</code>.
     *
     * ### Examples
     *
     * ```ts
     * conceptMap.concepts()
     * ```
     */
    concepts(): IterableIterator<Concept>;
    /**
     * Returns the inner <code>Map</code> where keys are query variables, and values are concepts.
     *
     * ### Examples
     *
     * ```ts
     * conceptMap.map()
     * ```
     */
    map(): Map<string, Concept>;
    /**
     * Retrieves a concept for a given variable name.
     *
     * ### Examples
     *
     * ```ts
     * conceptMap.get(variable)
     * ```
     *
     * @param variable - The string representation of a variable
     */
    get(variable: string): Concept;
    /**
     * The <code>Explainables</code> object for this <code>ConceptMap</code>,
     * exposing which of the concepts in this <code>ConceptMap</code> are explainable.
     */
    readonly explainables: ConceptMap.Explainables;
}
export declare namespace ConceptMap {
    /**
     * Contains explainable objects.
     */
    interface Explainables {
        /**
         * Retrieves the explainable relation with the given variable name.
         *
         * ### Examples
         *
         * ```ts
         * conceptMap.explainables.relation(variable)
         * ```
         *
         * @param variable - The string representation of a variable
         */
        relation(variable: string): Explainable;
        /**
         * Retrieves the explainable attribute with the given variable name.
         *
         * ### Examples
         *
         * ```ts
         * conceptMap.explainables.attribute(variable)
         * ```
         *
         * @param variable - The string representation of a variable
         */
        attribute(variable: string): Explainable;
        /**
         * Retrieves the explainable attribute ownership with the pair of (owner, attribute) variable names.
         *
         * ### Examples
         *
         * ```ts
         * conceptMap.explainables.ownership(owner, attribute)
         * ```
         *
         * @param owner - The string representation of the owner variable
         * @param attribute - The string representation of the attribute variable
         */
        ownership(owner: string, attribute: string): Explainable;
        /**
         * All of this <code>ConceptMap</code>’s explainable relations.
         */
        readonly relations: Map<string, Explainable>;
        /**
         * All of this <code>ConceptMap</code>’s explainable attributes.
         */
        readonly attributes: Map<string, Explainable>;
        /**
         * All of this <code>ConceptMap</code>’s explainable ownerships.
         */
        readonly ownerships: Map<[string, string], Explainable>;
    }
    /**
     * Contains an explainable object.
     */
    interface Explainable {
        /**
         * The subquery of the original query that is actually being explained.
         */
        readonly conjunction: string;
        /**
         * A unique ID that identifies this <code>Explainable</code>.
         */
        readonly id: number;
    }
}