kuzzle 2.31.0 → 2.32.0-beta.1

package/lib/service/storage/8/elasticsearch.d.ts

@@ -0,0 +1,972 @@
+import _ from "lodash";
+import { Client, estypes } from "sdk-es8";
+import { InfoResult, JSONObject, KRequestBody, KRequestParams, KStats, KUpdateResponse } from "../../../types/storage/8/Elasticsearch";
+import ESWrapper from "./esWrapper";
+import { QueryTranslator } from "../commons/queryTranslator";
+import { storeScopeEnum } from "../../../core/storage/storeScopeEnum";
+/**
+ * @param {Kuzzle} kuzzle kuzzle instance
+ * @param {Object} config Service configuration
+ * @param {storeScopeEnum} scope
+ * @constructor
+ */
+export declare class ES8 {
+    _client: Client;
+    _scope: storeScopeEnum;
+    _indexPrefix: string;
+    _esWrapper: ESWrapper;
+    _esVersion: any;
+    _translator: QueryTranslator;
+    searchBodyKeys: string[];
+    scriptKeys: string[];
+    scriptAllowedArgs: string[];
+    maxScrollDuration: number;
+    scrollTTL: number;
+    _config: any;
+    constructor(config: any, scope?: storeScopeEnum);
+    get scope(): storeScopeEnum;
+    /**
+     * Initializes the elasticsearch client
+     *
+     * @override
+     * @returns {Promise}
+     */
+    _initSequence(): Promise<void>;
+    /**
+     * Translate Koncorde filters to Elasticsearch query
+     *
+     * @param {Object} filters - Set of valid Koncorde filters
+     * @returns {Object} Equivalent Elasticsearch query
+     */
+    translateKoncordeFilters(filters: any): any;
+    /**
+     * Returns some basic information about this service
+     * @override
+     *
+     * @returns {Promise.<InfoResult>} service informations
+     */
+    info(): Promise<InfoResult>;
+    /**
+     * Returns detailed multi-level storage stats data
+     *
+     * @returns {Promise.<Object>}
+     */
+    stats(): Promise<KStats>;
+    /**
+     * Scrolls results from previous elasticsearch query.
+     * Automatically clears the scroll context after the last result page has
+     * been fetched.
+     *
+     * @param {String} scrollId - Scroll identifier
+     * @param {Object} options - scrollTTL (default scrollTTL)
+     *
+     * @returns {Promise.<{ scrollId, hits, aggregations, total }>}
+     */
+    scroll(scrollId: string, { scrollTTL }?: {
+        scrollTTL?: string;
+    }): Promise<{
+        aggregations: any;
+        hits: {
+            _id: any;
+            _score: any;
+            _source: any;
+            collection: any;
+            highlight: any;
+            index: any;
+            inner_hits: {};
+        }[];
+        remaining: number;
+        scrollId: any;
+        suggest: any;
+        total: any;
+    }>;
+    /**
+     * Searches documents from elasticsearch with a query
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} searchBody - Search request body (query, sort, etc.)
+     * @param {Object} options - from (undefined), size (undefined), scroll (undefined)
+     *
+     * @returns {Promise.<{ scrollId, hits, aggregations, suggest, total }>}
+     */
+    search({ index, collection, searchBody, targets, }?: {
+        index?: string;
+        collection?: string;
+        searchBody?: JSONObject;
+        targets?: any[];
+    }, { from, size, scroll, }?: {
+        from?: number;
+        size?: number;
+        scroll?: string;
+    }): Promise<{
+        aggregations: any;
+        hits: {
+            _id: any;
+            _score: any;
+            _source: any;
+            collection: any;
+            highlight: any;
+            index: any;
+            inner_hits: {};
+        }[];
+        remaining: number;
+        scrollId: any;
+        suggest: any;
+        total: any;
+    }>;
+    /**
+     * Generate a map that associate an alias to a pair of index and collection
+     *
+     * @param {*} targets
+     * @returns
+     */
+    _mapTargetsToAlias(targets: any): {};
+    _formatSearchResult(body: any, remaining?: number, searchInfo?: any): Promise<{
+        aggregations: any;
+        hits: {
+            _id: any;
+            _score: any;
+            _source: any;
+            collection: any;
+            highlight: any;
+            index: any;
+            inner_hits: {};
+        }[];
+        remaining: number;
+        scrollId: any;
+        suggest: any;
+        total: any;
+    }>;
+    /**
+     * Gets the document with given ID
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document ID
+     *
+     * @returns {Promise.<{ _id, _version, _source }>}
+     */
+    get(index: any, collection: any, id: any): Promise<any>;
+    /**
+     * Returns the list of documents matching the ids given in the body param
+     * NB: Due to internal Kuzzle mechanism, can only be called on a single
+     * index/collection, using the body { ids: [.. } syntax.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Array.<String>} ids - Document IDs
+     *
+     * @returns {Promise.<{ items: Array<{ _id, _source, _version }>, errors }>}
+     */
+    mGet(index: string, collection: string, ids: string[]): Promise<{
+        errors: any[];
+        item: any[];
+        items?: undefined;
+    } | {
+        errors: any[];
+        items: any[];
+        item?: undefined;
+    }>;
+    /**
+     * Counts how many documents match the filter given in body
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} searchBody - Search request body (query, sort, etc.)
+     *
+     * @returns {Promise.<Number>} count
+     */
+    count(index: string, collection: string, searchBody?: {}): Promise<number>;
+    /**
+     * Sends the new document to elasticsearch
+     * Cleans data to match elasticsearch specifications
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} content - Document content
+     * @param {Object} options - id (undefined), refresh (undefined), userId (null)
+     *
+     * @returns {Promise.<Object>} { _id, _version, _source }
+     */
+    create(index: string, collection: string, content: JSONObject, { id, refresh, userId, injectKuzzleMeta, }?: {
+        id?: string;
+        refresh?: boolean | "wait_for";
+        userId?: string;
+        injectKuzzleMeta?: boolean;
+    }): Promise<{
+        _id: string;
+        _source: KRequestBody<JSONObject>;
+        _version: number;
+    }>;
+    /**
+     * Creates a new document to Elasticsearch, or replace it if it already exist
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document id
+     * @param {Object} content - Document content
+     * @param {Object} options - refresh (undefined), userId (null), injectKuzzleMeta (true)
+     *
+     * @returns {Promise.<Object>} { _id, _version, _source, created }
+     */
+    createOrReplace(index: any, collection: any, id: any, content: any, { refresh, userId, injectKuzzleMeta, }?: {
+        refresh?: boolean | "wait_for";
+        userId?: string;
+        injectKuzzleMeta?: boolean;
+    }): Promise<{
+        _id: string;
+        _source: KRequestBody<JSONObject>;
+        _version: number;
+        created: boolean;
+    }>;
+    /**
+     * Sends the partial document to elasticsearch with the id to update
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document id
+     * @param {Object} content - Updated content
+     * @param {Object} options - refresh (undefined), userId (null), retryOnConflict (0)
+     *
+     * @returns {Promise.<{ _id, _version }>}
+     */
+    update(index: string, collection: string, id: string, content: JSONObject, { refresh, userId, retryOnConflict, injectKuzzleMeta, }?: {
+        refresh?: boolean | "wait_for";
+        userId?: string;
+        retryOnConflict?: number;
+        injectKuzzleMeta?: boolean;
+    }): Promise<KUpdateResponse>;
+    /**
+     * Sends the partial document to elasticsearch with the id to update
+     * Creates the document if it doesn't already exist
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document id
+     * @param {Object} content - Updated content
+     * @param {Object} options - defaultValues ({}), refresh (undefined), userId (null), retryOnConflict (0)
+     *
+     * @returns {Promise.<{ _id, _version }>}
+     */
+    upsert(index: string, collection: string, id: string, content: JSONObject, { defaultValues, refresh, userId, retryOnConflict, injectKuzzleMeta, }?: {
+        defaultValues?: JSONObject;
+        refresh?: boolean | "wait_for";
+        userId?: string;
+        retryOnConflict?: number;
+        injectKuzzleMeta?: boolean;
+    }): Promise<{
+        _id: string;
+        _source: unknown;
+        _version: number;
+        created: boolean;
+    }>;
+    /**
+     * Replaces a document to Elasticsearch
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document id
+     * @param {Object} content - Document content
+     * @param {Object} options - refresh (undefined), userId (null)
+     *
+     * @returns {Promise.<{ _id, _version, _source }>}
+     */
+    replace(index: string, collection: string, id: string, content: JSONObject, { refresh, userId, injectKuzzleMeta, }?: {
+        refresh?: boolean | "wait_for";
+        userId?: string;
+        injectKuzzleMeta?: boolean;
+    }): Promise<{
+        _id: string;
+        _source: KRequestBody<JSONObject>;
+        _version: number;
+    }>;
+    /**
+     * Sends to elasticsearch the document id to delete
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document id
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise}
+     */
+    delete(index: string, collection: string, id: string, { refresh, }?: {
+        refresh?: boolean | "wait_for";
+    }): Promise<any>;
+    /**
+     * Deletes all documents matching the provided filters.
+     * If fetch=false, the max documents write limit is not applied.
+     *
+     * Options:
+     *  - size: size of the batch to retrieve documents (no-op if fetch=false)
+     *  - refresh: refresh option for ES
+     *  - fetch: if true, will fetch the documents before delete them
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} query - Query to match documents
+     * @param {Object} options - size (undefined), refresh (undefined), fetch (true)
+     *
+     * @returns {Promise.<{ documents, total, deleted, failures: Array<{ id, reason }> }>}
+     */
+    deleteByQuery(index: string, collection: string, query: JSONObject, { refresh, size, fetch, }?: {
+        refresh?: boolean | "wait_for";
+        size?: number;
+        fetch?: boolean;
+    }): Promise<{
+        deleted: number;
+        documents: any[];
+        failures: {
+            id: string;
+            reason: string;
+        }[];
+        total: number;
+    }>;
+    /**
+     * Delete fields of a document and replace it
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document id
+     * @param {Array}  fields - Document fields to be removed
+     * @param {Object} options - refresh (undefined), userId (null)
+     *
+     * @returns {Promise.<{ _id, _version, _source }>}
+     */
+    deleteFields(index: string, collection: string, id: string, fields: string, { refresh, userId, }?: {
+        refresh?: boolean | "wait_for";
+        userId?: string;
+    }): Promise<{
+        _id: string;
+        _source: JSONObject;
+        _version: number;
+    }>;
+    /**
+     * Updates all documents matching the provided filters
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} query - Query to match documents
+     * @param {Object} changes - Changes wanted on documents
+     * @param {Object} options - refresh (undefined), size (undefined)
+     *
+     * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
+     */
+    updateByQuery(index: string, collection: string, query: JSONObject, changes: JSONObject, { refresh, size, userId, }?: {
+        refresh?: boolean | "wait_for";
+        size?: number;
+        userId?: string;
+    }): Promise<{
+        errors: any;
+        successes: any;
+    }>;
+    /**
+     * Updates all documents matching the provided filters
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} query - Query to match documents
+     * @param {Object} changes - Changes wanted on documents
+     * @param {Object} options - refresh (undefined)
+     *
+     * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
+     */
+    bulkUpdateByQuery(index: string, collection: string, query: JSONObject, changes: JSONObject, { refresh, }?: {
+        refresh?: boolean;
+    }): Promise<{
+        updated: number;
+    }>;
+    /**
+     * Execute the callback with a batch of documents of specified size until all
+     * documents matched by the query have been processed.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} query - Query to match documents
+     * @param {Function} callback - callback that will be called with the "hits" array
+     * @param {Object} options - size (10), scrollTTL ('5s')
+     *
+     * @returns {Promise.<any[]>} Array of results returned by the callback
+     */
+    mExecute(index: string, collection: string, query: JSONObject, callback: any, { size, scrollTTl, }?: {
+        size?: number;
+        scrollTTl?: string;
+    }): Promise<any>;
+    /**
+     * Creates a new index.
+     *
+     * This methods creates an hidden collection in the provided index to be
+     * able to list it.
+     * This methods resolves if the index name does not already exists either as
+     * private or public index.
+     *
+     * @param {String} index - Index name
+     *
+     * @returns {Promise}
+     */
+    createIndex(index: string): Promise<any>;
+    /**
+     * Creates an empty collection.
+     * Mappings and settings will be applied if supplied.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} config - mappings ({}), settings ({})
+     *
+     * @returns {Promise}
+     */
+    createCollection(index: string, collection: string, { mappings, settings, }?: {
+        mappings?: estypes.MappingTypeMapping;
+        settings?: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Retrieves settings definition for index/type
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     *
+     * @returns {Promise.<{ settings }>}
+     */
+    getSettings(index: string, collection: string): Promise<estypes.IndicesIndexSettings>;
+    /**
+     * Retrieves mapping definition for index/type
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} options - includeKuzzleMeta (false)
+     *
+     * @returns {Promise.<{ dynamic, _meta, properties }>}
+     */
+    getMapping(index: string, collection: string, { includeKuzzleMeta, }?: {
+        includeKuzzleMeta?: boolean;
+    }): Promise<{
+        _meta: estypes.Metadata;
+        dynamic: estypes.MappingDynamicMapping;
+        properties: Record<string, estypes.MappingProperty>;
+    }>;
+    /**
+     * Updates a collection mappings and settings
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} config - mappings ({}), settings ({})
+     *
+     * @returns {Promise}
+     */
+    updateCollection(index: string, collection: string, { mappings, settings, }?: {
+        mappings?: estypes.MappingTypeMapping;
+        settings?: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Given index settings we return a new version of index settings
+     * only with allowed settings that can be set (during update or create index).
+     * @param indexSettings the index settings
+     * @returns {{index: *}} a new index settings with only allowed settings.
+     */
+    getAllowedIndexSettings(indexSettings: any): {
+        index: _.Omit<any, "version" | "creation_date" | "provided_name" | "uuid">;
+    };
+    /**
+     * Sends an empty UpdateByQuery request to update the search index
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @returns {Promise.<Object>} {}
+     */
+    updateSearchIndex(index: string, collection: string): Promise<void>;
+    /**
+     * Update a collection mappings
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} mappings - Collection mappings in ES format
+     *
+     * @returns {Promise.<{ dynamic, _meta, properties }>}
+     */
+    updateMapping(index: string, collection: string, mappings?: estypes.MappingTypeMapping): Promise<{
+        dynamic: string;
+        _meta: JSONObject;
+        properties: JSONObject;
+    }>;
+    /**
+     * Updates a collection settings (eg: analyzers)
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object} settings - Collection settings in ES format
+     *
+     * @returns {Promise}
+     */
+    updateSettings(index: any, collection: any, settings?: {}): Promise<any>;
+    /**
+     * Empties the content of a collection. Keep the existing mapping and settings.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     *
+     * @returns {Promise}
+     */
+    truncateCollection(index: string, collection: string): Promise<any>;
+    /**
+     * Runs several action and document
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object[]} documents - Documents to import
+     * @param {Object} options - timeout (undefined), refresh (undefined), userId (null)
+     *
+     * @returns {Promise.<{ items, errors }>
+     */
+    import(index: string, collection: string, documents: JSONObject[], { refresh, timeout, userId, }?: {
+        refresh?: boolean | "wait_for";
+        timeout?: string;
+        userId?: string;
+    }): Promise<{
+        errors: any[];
+        items: any[];
+    }>;
+    /**
+     * Retrieves the complete list of existing collections in the current index
+     *
+     * @param {String} index - Index name
+     * @param {Object.Boolean} includeHidden - Optional: include HIDDEN_COLLECTION in results
+     *
+     * @returns {Promise.<Array>} Collection names
+     */
+    listCollections(index: string, { includeHidden }?: {
+        includeHidden?: boolean;
+    }): Promise<any>;
+    /**
+     * Retrieves the complete list of indexes
+     *
+     * @returns {Promise.<Array>} Index names
+     */
+    listIndexes(): Promise<string[]>;
+    /**
+     * Returns an object containing the list of indexes and collections
+     *
+     * @returns {Object.<String, String[]>} Object<index, collections>
+     */
+    getSchema(): Promise<{}>;
+    /**
+     * Retrieves the complete list of aliases
+     *
+     * @returns {Promise.<Object[]>} [ { alias, index, collection, indice } ]
+     */
+    listAliases(): Promise<any[]>;
+    /**
+     * Deletes a collection
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     *
+     * @returns {Promise}
+     */
+    deleteCollection(index: string, collection: string): Promise<void>;
+    /**
+     * Deletes multiple indexes
+     *
+     * @param {String[]} indexes - Index names
+     *
+     * @returns {Promise.<String[]>}
+     */
+    deleteIndexes(indexes?: string[]): Promise<any[]>;
+    /**
+     * Deletes an index
+     *
+     * @param {String} index - Index name
+     *
+     * @returns {Promise}
+     */
+    deleteIndex(index: string): Promise<void>;
+    /**
+     * Forces a refresh on the collection.
+     *
+     * /!\ Can lead to some performance issues.
+     * cf https://www.elastic.co/guide/en/elasticsearch/guide/current/near-real-time.html for more details
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     *
+     * @returns {Promise.<Object>} { _shards }
+     */
+    refreshCollection(index: string, collection: string): Promise<estypes.ShardsOperationResponseBase>;
+    /**
+     * Returns true if the document exists
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {String} id - Document ID
+     *
+     * @returns {Promise.<boolean>}
+     */
+    exists(index: string, collection: string, id: string): Promise<boolean>;
+    /**
+     * Returns the list of documents existing with the ids given in the body param
+     * NB: Due to internal Kuzzle mechanism, can only be called on a single
+     * index/collection, using the body { ids: [.. } syntax.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Array.<String>} ids - Document IDs
+     *
+     * @returns {Promise.<{ items: Array<{ _id, _source, _version }>, errors }>}
+     */
+    mExists(index: string, collection: string, ids: string[]): Promise<{
+        errors: any[];
+        item: any[];
+        items?: undefined;
+    } | {
+        errors: any[];
+        items: any[];
+        item?: undefined;
+    }>;
+    /**
+     * Returns true if the index exists
+     *
+     * @param {String} index - Index name
+     *
+     * @returns {Promise.<boolean>}
+     */
+    hasIndex(index: string): Promise<boolean>;
+    /**
+     * Returns true if the collection exists
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     *
+     * @returns {Promise.<boolean>}
+     */
+    hasCollection(index: string, collection: string): Promise<boolean>;
+    /**
+     * Returns true if the index has the hidden collection
+     *
+     * @param {String} index - Index name
+     *
+     * @returns {Promise.<boolean>}
+     */
+    _hasHiddenCollection(index: any): Promise<any>;
+    /**
+     * Creates multiple documents at once.
+     * If a content has no id, one is automatically generated and assigned to it.
+     * If a content has a specified identifier, it is rejected if it already exists
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object[]} documents - Documents
+     * @param {Object} options - timeout (undefined), refresh (undefined), userId (null)
+     *
+     * @returns {Promise.<Object>} { items, errors }
+     */
+    mCreate(index: string, collection: string, documents: JSON[], { refresh, timeout, userId, }?: {
+        refresh?: boolean | "wait_for";
+        timeout?: string;
+        userId?: string;
+    }): Promise<any>;
+    /**
+     * Creates or replaces multiple documents at once.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object[]} documents - Documents
+     * @param {Object} options - timeout (undefined), refresh (undefined), userId (null), injectKuzzleMeta (false), limits (true)
+     *
+     * @returns {Promise.<{ items, errors }>
+     */
+    mCreateOrReplace(index: string, collection: string, documents: JSONObject[], { refresh, timeout, userId, injectKuzzleMeta, limits, source, }?: KRequestParams): Promise<any>;
+    /**
+     * Updates multiple documents with one request
+     * Replacements are rejected if targeted documents do not exist
+     * (like with the normal "update" method)
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object[]} documents - Documents
+     * @param {Object} options - timeout (undefined), refresh (undefined), retryOnConflict (0), userId (null)
+     *
+     * @returns {Promise.<Object>} { items, errors }
+     */
+    mUpdate(index: string, collection: string, documents: JSONObject[], { refresh, retryOnConflict, timeout, userId, }?: {
+        refresh?: any;
+        retryOnConflict?: number;
+        timeout?: any;
+        userId?: any;
+    }): Promise<any>;
+    /**
+     * Creates or replaces multiple documents at once.
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object[]} documents - Documents
+     * @param {Object} options - refresh (undefined), retryOnConflict (0), timeout (undefined), userId (null)
+     *
+     * @returns {Promise.<{ items, errors }>
+     */
+    mUpsert(index: string, collection: string, documents: JSONObject[], { refresh, retryOnConflict, timeout, userId, }?: {
+        refresh?: boolean | "wait_for";
+        retryOnConflict?: number;
+        timeout?: string;
+        userId?: string;
+    }): Promise<any>;
+    /**
+     * Replaces multiple documents at once.
+     * Replacements are rejected if targeted documents do not exist
+     * (like with the normal "replace" method)
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Object[]} documents - Documents
+     * @param {Object} options - timeout (undefined), refresh (undefined), userId (null)
+     *
+     * @returns {Promise.<Object>} { items, errors }
+     */
+    mReplace(index: string, collection: string, documents: JSONObject[], { refresh, timeout, userId, }?: {
+        refresh?: boolean | "wait_for";
+        timeout?: string;
+        userId?: string;
+    }): Promise<any>;
+    /**
+     * Deletes multiple documents with one request
+     *
+     * @param {String} index - Index name
+     * @param {String} collection - Collection name
+     * @param {Array.<String>} ids - Documents IDs
+     * @param {Object} options - timeout (undefined), refresh (undefined)
+     *
+     * @returns {Promise.<{ documents, errors }>
+     */
+    mDelete(index: string, collection: string, ids: string[], { refresh, }?: {
+        refresh?: boolean | "wait_for";
+        timeout?: number;
+    }): Promise<{
+        documents: any[];
+        errors: any[];
+    }>;
+    /**
+     * Executes an ES request prepared by mcreate, mupdate, mreplace, mdelete or mwriteDocuments
+     * Returns a standardized ES response object, containing the list of
+     * successfully performed operations, and the rejected ones
+     *
+     * @param  {Object} esRequest - Elasticsearch request
+     * @param  {Object[]} documents - Document sources (format: {_id, _source})
+     * @param  {Object[]} partialErrors - pre-rejected documents
+     * @param  {Object} options - limits (true)
+     *
+     * @returns {Promise.<Object[]>} results
+     */
+    _mExecute(esRequest: estypes.BulkRequest, documents: JSONObject[], partialErrors?: JSONObject[], { limits, source }?: {
+        limits?: boolean;
+        source?: boolean;
+    }): Promise<any>;
+    /**
+     * Extracts, injects metadata and validates documents contained
+     * in a Request
+     *
+     * Used by mCreate, mUpdate, mUpsert, mReplace and mCreateOrReplace
+     *
+     * @param  {Object[]} documents - Documents
+     * @param  {Object} metadata - Kuzzle metadata
+     * @param  {Object} options - prepareMGet (false), requireId (false)
+     *
+     * @returns {Object} { rejected, extractedDocuments, documentsToGet }
+     */
+    _extractMDocuments(documents: JSONObject[], metadata: JSONObject, { prepareMGet, requireId, prepareMUpsert }?: {
+        prepareMGet?: boolean;
+        requireId?: boolean;
+        prepareMUpsert?: boolean;
+    }): {
+        documentsToGet: any[];
+        extractedDocuments: any[];
+        rejected: any[];
+    };
+    private _hasExceededLimit;
+    private _processExtract;
+    /**
+     * Throws an error if the provided mapping is invalid
+     *
+     * @param {Object} mapping
+     * @throws
+     */
+    _checkMappings(mapping: JSONObject, path?: any[], check?: boolean): void;
+    /**
+     * Given index + collection, returns the associated alias name.
+     * Prefer this function to `_getIndice` and `_getAvailableIndice` whenever it is possible.
+     *
+     * @param {String} index
+     * @param {String} collection
+     *
+     * @returns {String} Alias name (eg: '@&nepali.liia')
+     */
+    _getAlias(index: any, collection: any): string;
+    /**
+     * Given an alias name, returns the associated index name.
+     */
+    _checkIfAliasExists(aliasName: any): Promise<boolean>;
+    /**
+     * Given index + collection, returns the associated indice name.
+     * Use this function if ES does not accept aliases in the request. Otherwise use `_getAlias`.
+     *
+     * @param {String} index
+     * @param {String} collection
+     *
+     * @returns {String} Indice name (eg: '&nepali.liia')
+     * @throws If there is not exactly one indice associated
+     */
+    _getIndice(index: string, collection: string): Promise<string>;
+    /**
+     * Given an ES Request returns the settings of the corresponding indice.
+     *
+     * @param esRequest the ES Request with wanted settings.
+     * @return {Promise<*>} the settings of the indice.
+     * @private
+     */
+    _getSettings(esRequest: estypes.IndicesGetSettingsRequest): Promise<any>;
+    /**
+     * Given index + collection, returns an available indice name.
+     * Use this function when creating the associated indice. Otherwise use `_getAlias`.
+     *
+     * @param {String} index
+     * @param {String} collection
+     *
+     * @returns {String} Available indice name (eg: '&nepali.liia2')
+     */
+    _getAvailableIndice(index: string, collection: string): Promise<string>;
+    /**
+     * Given an indice, returns the associated alias name.
+     *
+     * @param {String} indice
+     *
+     * @returns {String} Alias name (eg: '@&nepali.liia')
+     * @throws If there is not exactly one alias associated that is prefixed with @
+     */
+    _getAliasFromIndice(indice: any): Promise<string[]>;
+    /**
+     * Check for each indice whether it has an alias or not.
+     * When the latter is missing, create one based on the indice name.
+     *
+     * This check avoids a breaking change for those who were using Kuzzle before
+     * alias attribution for each indice turned into a standard (appear in 2.14.0).
+     */
+    generateMissingAliases(): Promise<void>;
+    /**
+     * Throws if index or collection includes forbidden characters
+     *
+     * @param {String} index
+     * @param {String} collection
+     */
+    _assertValidIndexAndCollection(index: any, collection?: any): void;
+    /**
+     * Given an alias, extract the associated index.
+     *
+     * @param {String} alias
+     *
+     * @returns {String} Index name
+     */
+    _extractIndex(alias: any): any;
+    /**
+     * Given an alias, extract the associated collection.
+     *
+     * @param {String} alias
+     *
+     * @returns {String} Collection name
+     */
+    _extractCollection(alias: any): any;
+    /**
+     * Given aliases, extract indexes and collections.
+     *
+     * @param {Array.<String>} aliases
+     * @param {Object.Boolean} includeHidden Only refers to `HIDDEN_COLLECTION` occurences. An empty index will still be listed. Default to `false`.
+     *
+     * @returns {Object.<String, String[]>} Indexes as key and an array of their collections as value
+     */
+    _extractSchema(aliases: string[], { includeHidden }?: {
+        includeHidden?: boolean;
+    }): {};
+    /**
+     * Creates the hidden collection on the provided index if it does not already
+     * exists
+     *
+     * @param {String} index Index name
+     */
+    _createHiddenCollection(index: any): Promise<void>;
+    /**
+     * We need to always wait for a minimal number of shards to be available
+     * before answering to the client. This is to avoid Elasticsearch node
+     * to return a 404 Not Found error when the client tries to index a
+     * document in the index.
+     * To find the best value for this setting, we need to take into account
+     * the number of nodes in the cluster and the number of shards per index.
+     */
+    _getWaitForActiveShards(): Promise<estypes.WaitForActiveShards>;
+    /**
+     * Scroll indice in elasticsearch and return all document that match the filter
+     * /!\ throws a write_limit_exceed error: this method is intended to be used
+     * by deleteByQuery and updateByQuery
+     *
+     * @param {Object} esRequest - Search request body
+     *
+     * @returns {Promise.<Array>} resolve to an array of documents
+     */
+    _getAllDocumentsFromQuery(esRequest: estypes.SearchRequest): Promise<{
+        _id: any;
+        _source: any;
+        body: {};
+    }[]>;
+    /**
+     * Clean and normalize the searchBody
+     * Ensure only allowed parameters are passed to ES
+     *
+     * @param {Object} searchBody - ES search body (with query, aggregations, sort, etc)
+     */
+    _sanitizeSearchBody(searchBody: any): any;
+    /**
+     * Throw if a script is used in the query.
+     *
+     * Only Stored Scripts are accepted
+     *
+     * @param {Object} object
+     */
+    _scriptCheck(object: any): void;
+    /**
+     * Checks if a collection name is valid
+     * @param  {string}  name
+     * @returns {Boolean}
+     */
+    isCollectionNameValid(name: any): boolean;
+    /**
+     * Checks if a collection name is valid
+     * @param  {string}  name
+     * @returns {Boolean}
+     */
+    isIndexNameValid(name: any): boolean;
+    /**
+     * Clears an allocated scroll
+     * @param  {[type]} id [description]
+     * @returns {[type]}    [description]
+     */
+    clearScroll(id?: string): Promise<void>;
+    /**
+     * Loads a configuration value from services.storageEngine and assert a valid
+     * ms format.
+     *
+     * @param {String} key - relative path to the key in configuration
+     *
+     * @returns {Number} milliseconds
+     */
+    _loadMsConfig(key: any): number;
+    /**
+     * Returns true if one of the mappings dynamic property changes value from
+     * false to true
+     */
+    _dynamicChanges(previousMappings: any, newMappings: any): boolean;
+    waitForElasticsearch(): Promise<void>;
+    /**
+     * Checks if the dynamic properties are correct
+     */
+    _checkDynamicProperty(mappings: any): void;
+    _setLastActionToKuzzleMeta(esRequest: JSONObject, alias: string, kuzzleMeta: JSONObject): void;
+    _setLastActionToKuzzleMetaUpdate(item: JSONObject, kuzzleMeta: JSONObject): void;
+    _getHitsTotalValue(hits: estypes.SearchHitsMetadata): number;
+    _getRandomNumber(number: number): number;
+}