export declare class Lookup {
    constructor();
    /**
     * This method is used to lookup entities created by users and saved for their
     *  own personal use. How you implement that, if you do at all, is up to you.
     *  In desktop for example, when the user saves a template, that entity gets stored
     *  in their local database.
     *
     * @param {Object} params
     * @param {Array | String} params.type: the type array or type string of the entity being looked up
     * @param {String} params.queryString: the query string typed in by the user
     * @param {Number} params.limit=5: the number of matches to return - default = 5
     *
     * @returns {Object} { documents: [...]} - Object with documents array
     */
    entityTemplates({ type, queryString, limit }: {
        type?: undefined;
        queryString?: undefined;
        limit?: number | undefined;
    }): Promise<{
        documents: never[];
    }>;
    /**
     *
     * This method is used to lookup data packs. Data packs are JSON-LD snippets that
     *  have been created by an expert/s and can be trusted as being valid and correct.
     *
     * @param {Object} params
     * @param {Object} params.elasticQuery: a query object to be used against an elastic search server
     * @param {Array | String} params.type: the type array or type string of the entity being looked up
     * @param {String} params.queryString: the query string typed in by the user
     * @param {Array | String} params.fields: the fields to search against in the data pack json objects
     * @param {Array | String} params.datapack: the datapack or packs with the data to be used for this entity type
     * @param {Number} params.limit=10: the number of matches to return - default = 10
     *
     * @returns {Object} { documents: [...]} - Object with documents array
     */
    dataPacks({ elasticQuery, type, queryString, fields, datapacks, limit, }: {
        elasticQuery?: undefined;
        type?: undefined;
        queryString?: undefined;
        fields?: undefined;
        datapacks?: undefined;
        limit?: number | undefined;
    }): Promise<{
        documents: any;
    }>;
    /**
     * This method is used to lookup user created entities in, for example, a repository. Imagine
     *  a user creates an entity of type Country that overlaps with a Country in the data pack (same @id for both).
     *  The user created Country may not be correct but if it has the same @id and is stored
     *  in the same index, it will overrwrite the datapack version which is valid and correct.
     *
     * So, by separating out general entity lookups from data packs, you can store data in a way
     *  where user created stuff doesn't trample known good content.
     *
     * @param {Object} params
     * @param {Object} params.elasticQuery: a query object to be used against an elastic search server
     * @param {Array | String} params.type: the type array or type string of the entity being looked up
     * @param {String} params.queryString: the query string typed in by the user
     * @param {Array | String} params.fields: the fields to search against in the data pack json objects
     * @param {Array | String} params.datapack: the datapack or packs with the data to be used for this entity type
     * @param {Number} params.limit=10: the number of matches to return - default = 10
     * @returns {Object} { documents: [...]} - Object with documents array
     *
     * @returns
     */
    entities({ elasticQuery, type, queryString, fields, limit, }: {
        elasticQuery?: undefined;
        type?: undefined;
        queryString?: undefined;
        fields?: undefined;
        limit?: number | undefined;
    }): Promise<{
        documents: any;
    }>;
    /** private method */
    _execute({ query, indexPath }: {
        query: Record<string, any>;
        indexPath: string;
    }): Promise<any>;
}
