vendor/elasticsearch/elasticsearch/src/Traits/ClientEndpointsTrait.php line 1593

Open in your IDE?
  1. <?php
  3. /**
  4.  * Elasticsearch PHP Client
  5.  *
  6.  * @link      https://github.com/elastic/elasticsearch-php
  7.  * @copyright Copyright (c) Elasticsearch B.V (https://www.elastic.co)
  8.  * @license   https://opensource.org/licenses/MIT MIT License
  9.  *
  10.  * Licensed to Elasticsearch B.V under one or more agreements.
  11.  * Elasticsearch B.V licenses this file to you under the MIT License.
  12.  * See the LICENSE file in the project root for more information.
  13.  */
  15. declare(strict_types=1);
  17. namespace Elastic\Elasticsearch\Traits;
  19. use Elastic\Elasticsearch\Exception\ClientResponseException;
  20. use Elastic\Elasticsearch\Exception\MissingParameterException;
  21. use Elastic\Elasticsearch\Exception\ServerResponseException;
  22. use Elastic\Elasticsearch\Response\Elasticsearch;
  23. use Elastic\Transport\Exception\NoNodeAvailableException;
  24. use Http\Promise\Promise;
  26. /**
  27.  * @generated This file is generated, please do not edit
  28.  */
  29. trait ClientEndpointsTrait
  30. {
  31.     /**
  32.      * Allows to perform multiple index/update/delete operations in a single request.
  33.      *
  34.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-bulk.html
  35.      *
  36.      * @param array{
  37.      *     index: string, //  Default index for items which don't provide one
  38.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  39.      *     refresh: enum, // If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
  40.      *     routing: string, // Specific routing value
  41.      *     timeout: time, // Explicit operation timeout
  42.      *     type: string, // Default document type for items which don't provide one
  43.      *     _source: list, // True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
  44.      *     _source_excludes: list, // Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
  45.      *     _source_includes: list, // Default list of fields to extract and return from the _source field, can be overridden on each sub-request
  46.      *     pipeline: string, // The pipeline id to preprocess incoming documents with
  47.      *     require_alias: boolean, // Sets require_alias for all incoming documents. Defaults to unset (false)
  48.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  49.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  50.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  51.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  52.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  53.      *     body: array, // (REQUIRED) The operation definition and data (action-data pairs), separated by newlines
  54.      * } $params
  55.      *
  56.      * @throws NoNodeAvailableException if all the hosts are offline
  57.      * @throws ClientResponseException if the status code of response is 4xx
  58.      * @throws ServerResponseException if the status code of response is 5xx
  59.      *
  60.      * @return Elasticsearch|Promise
  61.      */
  62.     public function bulk(array $params = [])
  63.     {
  64.         $this->checkRequiredParameters(['body'], $params);
  65.         if (isset($params['index'])) {
  66.             $url = '/' . $this->encode($params['index']) . '/_bulk';
  67.             $method = 'POST';
  68.         } else {
  69.             $url = '/_bulk';
  70.             $method = 'POST';
  71.         }
  72.         $url = $this->addQueryString($url, $params, ['wait_for_active_shards','refresh','routing','timeout','type','_source','_source_excludes','_source_includes','pipeline','require_alias','pretty','human','error_trace','source','filter_path']);
  73.         $headers = [
  74.             'Accept' => 'application/json',
  75.             'Content-Type' => 'application/x-ndjson',
  76.         ];
  77.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  78.     }
  81.     /**
  82.      * Explicitly clears the search context for a scroll.
  83.      *
  84.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/clear-scroll-api.html
  85.      *
  86.      * @param array{
  87.      *     scroll_id: list, //  A comma-separated list of scroll IDs to clear
  88.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  89.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  90.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  91.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  92.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  93.      *     body: array, //  A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter
  94.      * } $params
  95.      *
  96.      * @throws NoNodeAvailableException if all the hosts are offline
  97.      * @throws ClientResponseException if the status code of response is 4xx
  98.      * @throws ServerResponseException if the status code of response is 5xx
  99.      *
  100.      * @return Elasticsearch|Promise
  101.      */
  102.     public function clearScroll(array $params = [])
  103.     {
  104.         if (isset($params['scroll_id'])) {
  105.             $url = '/_search/scroll/' . $this->encode($params['scroll_id']);
  106.             $method = 'DELETE';
  107.         } else {
  108.             $url = '/_search/scroll';
  109.             $method = 'DELETE';
  110.         }
  111.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  112.         $headers = [
  113.             'Accept' => 'application/json',
  114.             'Content-Type' => 'application/json',
  115.         ];
  116.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  117.     }
  120.     /**
  121.      * Close a point in time
  122.      *
  123.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/point-in-time-api.html
  124.      *
  125.      * @param array{
  126.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  127.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  128.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  129.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  130.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  131.      *     body: array, //  a point-in-time id to close
  132.      * } $params
  133.      *
  134.      * @throws NoNodeAvailableException if all the hosts are offline
  135.      * @throws ClientResponseException if the status code of response is 4xx
  136.      * @throws ServerResponseException if the status code of response is 5xx
  137.      *
  138.      * @return Elasticsearch|Promise
  139.      */
  140.     public function closePointInTime(array $params = [])
  141.     {
  142.         $url = '/_pit';
  143.         $method = 'DELETE';
  145.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  146.         $headers = [
  147.             'Accept' => 'application/json',
  148.             'Content-Type' => 'application/json',
  149.         ];
  150.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  151.     }
  154.     /**
  155.      * Returns number of documents matching a query.
  156.      *
  157.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-count.html
  158.      *
  159.      * @param array{
  160.      *     index: list, //  A comma-separated list of indices to restrict the results
  161.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  162.      *     ignore_throttled: boolean, // Whether specified concrete, expanded or aliased indices should be ignored when throttled
  163.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  164.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  165.      *     min_score: number, // Include only documents with a specific `_score` value in the result
  166.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  167.      *     routing: list, // A comma-separated list of specific routing values
  168.      *     q: string, // Query in the Lucene query string syntax
  169.      *     analyzer: string, // The analyzer to use for the query string
  170.      *     analyze_wildcard: boolean, // Specify whether wildcard and prefix queries should be analyzed (default: false)
  171.      *     default_operator: enum, // The default operator for query string query (AND or OR)
  172.      *     df: string, // The field to use as default where no field prefix is given in the query string
  173.      *     lenient: boolean, // Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
  174.      *     terminate_after: number, // The maximum count for each shard, upon reaching which the query execution will terminate early
  175.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  176.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  177.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  178.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  179.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  180.      *     body: array, //  A query to restrict the results specified with the Query DSL (optional)
  181.      * } $params
  182.      *
  183.      * @throws NoNodeAvailableException if all the hosts are offline
  184.      * @throws ClientResponseException if the status code of response is 4xx
  185.      * @throws ServerResponseException if the status code of response is 5xx
  186.      *
  187.      * @return Elasticsearch|Promise
  188.      */
  189.     public function count(array $params = [])
  190.     {
  191.         if (isset($params['index'])) {
  192.             $url = '/' . $this->encode($params['index']) . '/_count';
  193.             $method = empty($params['body']) ? 'GET' : 'POST';
  194.         } else {
  195.             $url = '/_count';
  196.             $method = empty($params['body']) ? 'GET' : 'POST';
  197.         }
  198.         $url = $this->addQueryString($url, $params, ['ignore_unavailable','ignore_throttled','allow_no_indices','expand_wildcards','min_score','preference','routing','q','analyzer','analyze_wildcard','default_operator','df','lenient','terminate_after','pretty','human','error_trace','source','filter_path']);
  199.         $headers = [
  200.             'Accept' => 'application/json',
  201.             'Content-Type' => 'application/json',
  202.         ];
  203.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  204.     }
  207.     /**
  208.      * Creates a new document in the index.
  209.      *
  210.      * Returns a 409 response when a document with a same ID already exists in the index.
  211.      *
  212.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-index_.html
  213.      *
  214.      * @param array{
  215.      *     id: string, // (REQUIRED) Document ID
  216.      *     index: string, // (REQUIRED) The name of the index
  217.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  218.      *     refresh: enum, // If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
  219.      *     routing: string, // Specific routing value
  220.      *     timeout: time, // Explicit operation timeout
  221.      *     version: number, // Explicit version number for concurrency control
  222.      *     version_type: enum, // Specific version type
  223.      *     pipeline: string, // The pipeline id to preprocess incoming documents with
  224.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  225.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  226.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  227.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  228.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  229.      *     body: array, // (REQUIRED) The document
  230.      * } $params
  231.      *
  232.      * @throws MissingParameterException if a required parameter is missing
  233.      * @throws NoNodeAvailableException if all the hosts are offline
  234.      * @throws ClientResponseException if the status code of response is 4xx
  235.      * @throws ServerResponseException if the status code of response is 5xx
  236.      *
  237.      * @return Elasticsearch|Promise
  238.      */
  239.     public function create(array $params = [])
  240.     {
  241.         $this->checkRequiredParameters(['id','index','body'], $params);
  242.         $url = '/' . $this->encode($params['index']) . '/_create/' . $this->encode($params['id']);
  243.         $method = 'PUT';
  245.         $url = $this->addQueryString($url, $params, ['wait_for_active_shards','refresh','routing','timeout','version','version_type','pipeline','pretty','human','error_trace','source','filter_path']);
  246.         $headers = [
  247.             'Accept' => 'application/json',
  248.             'Content-Type' => 'application/json',
  249.         ];
  250.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  251.     }
  254.     /**
  255.      * Removes a document from the index.
  256.      *
  257.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete.html
  258.      *
  259.      * @param array{
  260.      *     id: string, // (REQUIRED) The document ID
  261.      *     index: string, // (REQUIRED) The name of the index
  262.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  263.      *     refresh: enum, // If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
  264.      *     routing: string, // Specific routing value
  265.      *     timeout: time, // Explicit operation timeout
  266.      *     if_seq_no: number, // only perform the delete operation if the last operation that has changed the document has the specified sequence number
  267.      *     if_primary_term: number, // only perform the delete operation if the last operation that has changed the document has the specified primary term
  268.      *     version: number, // Explicit version number for concurrency control
  269.      *     version_type: enum, // Specific version type
  270.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  271.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  272.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  273.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  274.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  275.      * } $params
  276.      *
  277.      * @throws MissingParameterException if a required parameter is missing
  278.      * @throws NoNodeAvailableException if all the hosts are offline
  279.      * @throws ClientResponseException if the status code of response is 4xx
  280.      * @throws ServerResponseException if the status code of response is 5xx
  281.      *
  282.      * @return Elasticsearch|Promise
  283.      */
  284.     public function delete(array $params = [])
  285.     {
  286.         $this->checkRequiredParameters(['id','index'], $params);
  287.         $url = '/' . $this->encode($params['index']) . '/_doc/' . $this->encode($params['id']);
  288.         $method = 'DELETE';
  290.         $url = $this->addQueryString($url, $params, ['wait_for_active_shards','refresh','routing','timeout','if_seq_no','if_primary_term','version','version_type','pretty','human','error_trace','source','filter_path']);
  291.         $headers = [
  292.             'Accept' => 'application/json',
  293.         ];
  294.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  295.     }
  298.     /**
  299.      * Deletes documents matching the provided query.
  300.      *
  301.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete-by-query.html
  302.      *
  303.      * @param array{
  304.      *     index: list, // (REQUIRED) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  305.      *     analyzer: string, // The analyzer to use for the query string
  306.      *     analyze_wildcard: boolean, // Specify whether wildcard and prefix queries should be analyzed (default: false)
  307.      *     default_operator: enum, // The default operator for query string query (AND or OR)
  308.      *     df: string, // The field to use as default where no field prefix is given in the query string
  309.      *     from: number, // Starting offset (default: 0)
  310.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  311.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  312.      *     conflicts: enum, // What to do when the delete by query hits version conflicts?
  313.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  314.      *     lenient: boolean, // Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
  315.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  316.      *     q: string, // Query in the Lucene query string syntax
  317.      *     routing: list, // A comma-separated list of specific routing values
  318.      *     scroll: time, // Specify how long a consistent view of the index should be maintained for scrolled search
  319.      *     search_type: enum, // Search operation type
  320.      *     search_timeout: time, // Explicit timeout for each search request. Defaults to no timeout.
  321.      *     max_docs: number, // Maximum number of documents to process (default: all documents)
  322.      *     sort: list, // A comma-separated list of <field>:<direction> pairs
  323.      *     terminate_after: number, // The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
  324.      *     stats: list, // Specific 'tag' of the request for logging and statistical purposes
  325.      *     version: boolean, // Specify whether to return document version as part of a hit
  326.      *     request_cache: boolean, // Specify if request cache should be used for this request or not, defaults to index level setting
  327.      *     refresh: boolean, // Should the affected indexes be refreshed?
  328.      *     timeout: time, // Time each individual bulk request should wait for shards that are unavailable.
  329.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  330.      *     scroll_size: number, // Size on the scroll request powering the delete by query
  331.      *     wait_for_completion: boolean, // Should the request should block until the delete by query is complete.
  332.      *     requests_per_second: number, // The throttle for this request in sub-requests per second. -1 means no throttle.
  333.      *     slices: number|string, // The number of slices this task should be divided into. Defaults to 1, meaning the task isn't sliced into subtasks. Can be set to `auto`.
  334.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  335.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  336.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  337.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  338.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  339.      *     body: array, // (REQUIRED) The search definition using the Query DSL
  340.      * } $params
  341.      *
  342.      * @throws MissingParameterException if a required parameter is missing
  343.      * @throws NoNodeAvailableException if all the hosts are offline
  344.      * @throws ClientResponseException if the status code of response is 4xx
  345.      * @throws ServerResponseException if the status code of response is 5xx
  346.      *
  347.      * @return Elasticsearch|Promise
  348.      */
  349.     public function deleteByQuery(array $params = [])
  350.     {
  351.         $this->checkRequiredParameters(['index','body'], $params);
  352.         $url = '/' . $this->encode($params['index']) . '/_delete_by_query';
  353.         $method = 'POST';
  355.         $url = $this->addQueryString($url, $params, ['analyzer','analyze_wildcard','default_operator','df','from','ignore_unavailable','allow_no_indices','conflicts','expand_wildcards','lenient','preference','q','routing','scroll','search_type','search_timeout','max_docs','sort','terminate_after','stats','version','request_cache','refresh','timeout','wait_for_active_shards','scroll_size','wait_for_completion','requests_per_second','slices','pretty','human','error_trace','source','filter_path']);
  356.         $headers = [
  357.             'Accept' => 'application/json',
  358.             'Content-Type' => 'application/json',
  359.         ];
  360.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  361.     }
  364.     /**
  365.      * Changes the number of requests per second for a particular Delete By Query operation.
  366.      *
  367.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
  368.      *
  369.      * @param array{
  370.      *     task_id: string, // (REQUIRED) The task id to rethrottle
  371.      *     requests_per_second: number, // The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
  372.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  373.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  374.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  375.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  376.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  377.      * } $params
  378.      *
  379.      * @throws MissingParameterException if a required parameter is missing
  380.      * @throws NoNodeAvailableException if all the hosts are offline
  381.      * @throws ClientResponseException if the status code of response is 4xx
  382.      * @throws ServerResponseException if the status code of response is 5xx
  383.      *
  384.      * @return Elasticsearch|Promise
  385.      */
  386.     public function deleteByQueryRethrottle(array $params = [])
  387.     {
  388.         $this->checkRequiredParameters(['task_id','requests_per_second'], $params);
  389.         $url = '/_delete_by_query/' . $this->encode($params['task_id']) . '/_rethrottle';
  390.         $method = 'POST';
  392.         $url = $this->addQueryString($url, $params, ['requests_per_second','pretty','human','error_trace','source','filter_path']);
  393.         $headers = [
  394.             'Accept' => 'application/json',
  395.         ];
  396.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  397.     }
  400.     /**
  401.      * Deletes a script.
  402.      *
  403.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html
  404.      *
  405.      * @param array{
  406.      *     id: string, // (REQUIRED) Script ID
  407.      *     timeout: time, // Explicit operation timeout
  408.      *     master_timeout: time, // Specify timeout for connection to master
  409.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  410.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  411.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  412.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  413.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  414.      * } $params
  415.      *
  416.      * @throws MissingParameterException if a required parameter is missing
  417.      * @throws NoNodeAvailableException if all the hosts are offline
  418.      * @throws ClientResponseException if the status code of response is 4xx
  419.      * @throws ServerResponseException if the status code of response is 5xx
  420.      *
  421.      * @return Elasticsearch|Promise
  422.      */
  423.     public function deleteScript(array $params = [])
  424.     {
  425.         $this->checkRequiredParameters(['id'], $params);
  426.         $url = '/_scripts/' . $this->encode($params['id']);
  427.         $method = 'DELETE';
  429.         $url = $this->addQueryString($url, $params, ['timeout','master_timeout','pretty','human','error_trace','source','filter_path']);
  430.         $headers = [
  431.             'Accept' => 'application/json',
  432.         ];
  433.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  434.     }
  437.     /**
  438.      * Returns information about whether a document exists in an index.
  439.      *
  440.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html
  441.      *
  442.      * @param array{
  443.      *     id: string, // (REQUIRED) The document ID
  444.      *     index: string, // (REQUIRED) The name of the index
  445.      *     stored_fields: list, // A comma-separated list of stored fields to return in the response
  446.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  447.      *     realtime: boolean, // Specify whether to perform the operation in realtime or search mode
  448.      *     refresh: boolean, // Refresh the shard containing the document before performing the operation
  449.      *     routing: string, // Specific routing value
  450.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  451.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  452.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  453.      *     version: number, // Explicit version number for concurrency control
  454.      *     version_type: enum, // Specific version type
  455.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  456.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  457.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  458.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  459.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  460.      * } $params
  461.      *
  462.      * @throws MissingParameterException if a required parameter is missing
  463.      * @throws NoNodeAvailableException if all the hosts are offline
  464.      * @throws ClientResponseException if the status code of response is 4xx
  465.      * @throws ServerResponseException if the status code of response is 5xx
  466.      *
  467.      * @return Elasticsearch|Promise
  468.      */
  469.     public function exists(array $params = [])
  470.     {
  471.         $this->checkRequiredParameters(['id','index'], $params);
  472.         $url = '/' . $this->encode($params['index']) . '/_doc/' . $this->encode($params['id']);
  473.         $method = 'HEAD';
  475.         $url = $this->addQueryString($url, $params, ['stored_fields','preference','realtime','refresh','routing','_source','_source_excludes','_source_includes','version','version_type','pretty','human','error_trace','source','filter_path']);
  476.         $headers = [
  477.             'Accept' => 'application/json',
  478.         ];
  479.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  480.     }
  483.     /**
  484.      * Returns information about whether a document source exists in an index.
  485.      *
  486.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html
  487.      *
  488.      * @param array{
  489.      *     id: string, // (REQUIRED) The document ID
  490.      *     index: string, // (REQUIRED) The name of the index
  491.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  492.      *     realtime: boolean, // Specify whether to perform the operation in realtime or search mode
  493.      *     refresh: boolean, // Refresh the shard containing the document before performing the operation
  494.      *     routing: string, // Specific routing value
  495.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  496.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  497.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  498.      *     version: number, // Explicit version number for concurrency control
  499.      *     version_type: enum, // Specific version type
  500.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  501.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  502.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  503.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  504.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  505.      * } $params
  506.      *
  507.      * @throws MissingParameterException if a required parameter is missing
  508.      * @throws NoNodeAvailableException if all the hosts are offline
  509.      * @throws ClientResponseException if the status code of response is 4xx
  510.      * @throws ServerResponseException if the status code of response is 5xx
  511.      *
  512.      * @return Elasticsearch|Promise
  513.      */
  514.     public function existsSource(array $params = [])
  515.     {
  516.         $this->checkRequiredParameters(['id','index'], $params);
  517.         $url = '/' . $this->encode($params['index']) . '/_source/' . $this->encode($params['id']);
  518.         $method = 'HEAD';
  520.         $url = $this->addQueryString($url, $params, ['preference','realtime','refresh','routing','_source','_source_excludes','_source_includes','version','version_type','pretty','human','error_trace','source','filter_path']);
  521.         $headers = [
  522.             'Accept' => 'application/json',
  523.         ];
  524.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  525.     }
  528.     /**
  529.      * Returns information about why a specific matches (or doesn't match) a query.
  530.      *
  531.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-explain.html
  532.      *
  533.      * @param array{
  534.      *     id: string, // (REQUIRED) The document ID
  535.      *     index: string, // (REQUIRED) The name of the index
  536.      *     analyze_wildcard: boolean, // Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
  537.      *     analyzer: string, // The analyzer for the query string query
  538.      *     default_operator: enum, // The default operator for query string query (AND or OR)
  539.      *     df: string, // The default field for query string query (default: _all)
  540.      *     stored_fields: list, // A comma-separated list of stored fields to return in the response
  541.      *     lenient: boolean, // Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
  542.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  543.      *     q: string, // Query in the Lucene query string syntax
  544.      *     routing: string, // Specific routing value
  545.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  546.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  547.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  548.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  549.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  550.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  551.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  552.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  553.      *     body: array, //  The query definition using the Query DSL
  554.      * } $params
  555.      *
  556.      * @throws MissingParameterException if a required parameter is missing
  557.      * @throws NoNodeAvailableException if all the hosts are offline
  558.      * @throws ClientResponseException if the status code of response is 4xx
  559.      * @throws ServerResponseException if the status code of response is 5xx
  560.      *
  561.      * @return Elasticsearch|Promise
  562.      */
  563.     public function explain(array $params = [])
  564.     {
  565.         $this->checkRequiredParameters(['id','index'], $params);
  566.         $url = '/' . $this->encode($params['index']) . '/_explain/' . $this->encode($params['id']);
  567.         $method = empty($params['body']) ? 'GET' : 'POST';
  569.         $url = $this->addQueryString($url, $params, ['analyze_wildcard','analyzer','default_operator','df','stored_fields','lenient','preference','q','routing','_source','_source_excludes','_source_includes','pretty','human','error_trace','source','filter_path']);
  570.         $headers = [
  571.             'Accept' => 'application/json',
  572.             'Content-Type' => 'application/json',
  573.         ];
  574.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  575.     }
  578.     /**
  579.      * Returns the information about the capabilities of fields among multiple indices.
  580.      *
  581.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-field-caps.html
  582.      *
  583.      * @param array{
  584.      *     index: list, //  A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
  585.      *     fields: list, // A comma-separated list of field names
  586.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  587.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  588.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  589.      *     include_unmapped: boolean, // Indicates whether unmapped fields should be included in the response.
  590.      *     filters: list, // An optional set of filters: can include +metadata,-metadata,-nested,-multifield,-parent
  591.      *     types: list, // Only return results for fields that have one of the types in the list
  592.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  593.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  594.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  595.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  596.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  597.      *     body: array, //  An index filter specified with the Query DSL
  598.      * } $params
  599.      *
  600.      * @throws NoNodeAvailableException if all the hosts are offline
  601.      * @throws ClientResponseException if the status code of response is 4xx
  602.      * @throws ServerResponseException if the status code of response is 5xx
  603.      *
  604.      * @return Elasticsearch|Promise
  605.      */
  606.     public function fieldCaps(array $params = [])
  607.     {
  608.         if (isset($params['index'])) {
  609.             $url = '/' . $this->encode($params['index']) . '/_field_caps';
  610.             $method = empty($params['body']) ? 'GET' : 'POST';
  611.         } else {
  612.             $url = '/_field_caps';
  613.             $method = empty($params['body']) ? 'GET' : 'POST';
  614.         }
  615.         $url = $this->addQueryString($url, $params, ['fields','ignore_unavailable','allow_no_indices','expand_wildcards','include_unmapped','filters','types','pretty','human','error_trace','source','filter_path']);
  616.         $headers = [
  617.             'Accept' => 'application/json',
  618.             'Content-Type' => 'application/json',
  619.         ];
  620.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  621.     }
  624.     /**
  625.      * Returns a document.
  626.      *
  627.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html
  628.      *
  629.      * @param array{
  630.      *     id: string, // (REQUIRED) The document ID
  631.      *     index: string, // (REQUIRED) The name of the index
  632.      *     force_synthetic_source: boolean, // Should this request force synthetic _source? Use this to test if the mapping supports synthetic _source and to get a sense of the worst case performance. Fetches with this enabled will be slower the enabling synthetic source natively in the index.
  633.      *     stored_fields: list, // A comma-separated list of stored fields to return in the response
  634.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  635.      *     realtime: boolean, // Specify whether to perform the operation in realtime or search mode
  636.      *     refresh: boolean, // Refresh the shard containing the document before performing the operation
  637.      *     routing: string, // Specific routing value
  638.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  639.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  640.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  641.      *     version: number, // Explicit version number for concurrency control
  642.      *     version_type: enum, // Specific version type
  643.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  644.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  645.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  646.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  647.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  648.      * } $params
  649.      *
  650.      * @throws MissingParameterException if a required parameter is missing
  651.      * @throws NoNodeAvailableException if all the hosts are offline
  652.      * @throws ClientResponseException if the status code of response is 4xx
  653.      * @throws ServerResponseException if the status code of response is 5xx
  654.      *
  655.      * @return Elasticsearch|Promise
  656.      */
  657.     public function get(array $params = [])
  658.     {
  659.         $this->checkRequiredParameters(['id','index'], $params);
  660.         $url = '/' . $this->encode($params['index']) . '/_doc/' . $this->encode($params['id']);
  661.         $method = 'GET';
  663.         $url = $this->addQueryString($url, $params, ['force_synthetic_source','stored_fields','preference','realtime','refresh','routing','_source','_source_excludes','_source_includes','version','version_type','pretty','human','error_trace','source','filter_path']);
  664.         $headers = [
  665.             'Accept' => 'application/json',
  666.         ];
  667.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  668.     }
  671.     /**
  672.      * Returns a script.
  673.      *
  674.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html
  675.      *
  676.      * @param array{
  677.      *     id: string, // (REQUIRED) Script ID
  678.      *     master_timeout: time, // Specify timeout for connection to master
  679.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  680.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  681.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  682.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  683.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  684.      * } $params
  685.      *
  686.      * @throws MissingParameterException if a required parameter is missing
  687.      * @throws NoNodeAvailableException if all the hosts are offline
  688.      * @throws ClientResponseException if the status code of response is 4xx
  689.      * @throws ServerResponseException if the status code of response is 5xx
  690.      *
  691.      * @return Elasticsearch|Promise
  692.      */
  693.     public function getScript(array $params = [])
  694.     {
  695.         $this->checkRequiredParameters(['id'], $params);
  696.         $url = '/_scripts/' . $this->encode($params['id']);
  697.         $method = 'GET';
  699.         $url = $this->addQueryString($url, $params, ['master_timeout','pretty','human','error_trace','source','filter_path']);
  700.         $headers = [
  701.             'Accept' => 'application/json',
  702.         ];
  703.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  704.     }
  707.     /**
  708.      * Returns all script contexts.
  709.      *
  710.      * @see https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-contexts.html
  711.      *
  712.      * @param array{
  713.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  714.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  715.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  716.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  717.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  718.      * } $params
  719.      *
  720.      * @throws NoNodeAvailableException if all the hosts are offline
  721.      * @throws ClientResponseException if the status code of response is 4xx
  722.      * @throws ServerResponseException if the status code of response is 5xx
  723.      *
  724.      * @return Elasticsearch|Promise
  725.      */
  726.     public function getScriptContext(array $params = [])
  727.     {
  728.         $url = '/_script_context';
  729.         $method = 'GET';
  731.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  732.         $headers = [
  733.             'Accept' => 'application/json',
  734.         ];
  735.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  736.     }
  739.     /**
  740.      * Returns available script types, languages and contexts
  741.      *
  742.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html
  743.      *
  744.      * @param array{
  745.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  746.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  747.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  748.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  749.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  750.      * } $params
  751.      *
  752.      * @throws NoNodeAvailableException if all the hosts are offline
  753.      * @throws ClientResponseException if the status code of response is 4xx
  754.      * @throws ServerResponseException if the status code of response is 5xx
  755.      *
  756.      * @return Elasticsearch|Promise
  757.      */
  758.     public function getScriptLanguages(array $params = [])
  759.     {
  760.         $url = '/_script_language';
  761.         $method = 'GET';
  763.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  764.         $headers = [
  765.             'Accept' => 'application/json',
  766.         ];
  767.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  768.     }
  771.     /**
  772.      * Returns the source of a document.
  773.      *
  774.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html
  775.      *
  776.      * @param array{
  777.      *     id: string, // (REQUIRED) The document ID
  778.      *     index: string, // (REQUIRED) The name of the index
  779.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  780.      *     realtime: boolean, // Specify whether to perform the operation in realtime or search mode
  781.      *     refresh: boolean, // Refresh the shard containing the document before performing the operation
  782.      *     routing: string, // Specific routing value
  783.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  784.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  785.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  786.      *     version: number, // Explicit version number for concurrency control
  787.      *     version_type: enum, // Specific version type
  788.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  789.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  790.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  791.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  792.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  793.      * } $params
  794.      *
  795.      * @throws MissingParameterException if a required parameter is missing
  796.      * @throws NoNodeAvailableException if all the hosts are offline
  797.      * @throws ClientResponseException if the status code of response is 4xx
  798.      * @throws ServerResponseException if the status code of response is 5xx
  799.      *
  800.      * @return Elasticsearch|Promise
  801.      */
  802.     public function getSource(array $params = [])
  803.     {
  804.         $this->checkRequiredParameters(['id','index'], $params);
  805.         $url = '/' . $this->encode($params['index']) . '/_source/' . $this->encode($params['id']);
  806.         $method = 'GET';
  808.         $url = $this->addQueryString($url, $params, ['preference','realtime','refresh','routing','_source','_source_excludes','_source_includes','version','version_type','pretty','human','error_trace','source','filter_path']);
  809.         $headers = [
  810.             'Accept' => 'application/json',
  811.         ];
  812.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  813.     }
  816.     /**
  817.      * Returns the health of the cluster.
  818.      *
  819.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/health-api.html
  820.      *
  821.      * @param array{
  822.      *     feature: string, //  A feature of the cluster, as returned by the top-level health API
  823.      *     timeout: time, // Explicit operation timeout
  824.      *     verbose: boolean, // Opt in for more information about the health of the system
  825.      *     size: int, // Limit the number of affected resources the health API returns
  826.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  827.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  828.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  829.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  830.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  831.      * } $params
  832.      *
  833.      * @throws NoNodeAvailableException if all the hosts are offline
  834.      * @throws ClientResponseException if the status code of response is 4xx
  835.      * @throws ServerResponseException if the status code of response is 5xx
  836.      *
  837.      * @return Elasticsearch|Promise
  838.      */
  839.     public function healthReport(array $params = [])
  840.     {
  841.         if (isset($params['feature'])) {
  842.             $url = '/_health_report/' . $this->encode($params['feature']);
  843.             $method = 'GET';
  844.         } else {
  845.             $url = '/_health_report';
  846.             $method = 'GET';
  847.         }
  848.         $url = $this->addQueryString($url, $params, ['timeout','verbose','size','pretty','human','error_trace','source','filter_path']);
  849.         $headers = [
  850.             'Accept' => 'application/json',
  851.         ];
  852.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  853.     }
  856.     /**
  857.      * Creates or updates a document in an index.
  858.      *
  859.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-index_.html
  860.      *
  861.      * @param array{
  862.      *     id: string, //  Document ID
  863.      *     index: string, // (REQUIRED) The name of the index
  864.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  865.      *     op_type: enum, // Explicit operation type. Defaults to `index` for requests with an explicit document ID, and to `create`for requests without an explicit document ID
  866.      *     refresh: enum, // If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
  867.      *     routing: string, // Specific routing value
  868.      *     timeout: time, // Explicit operation timeout
  869.      *     version: number, // Explicit version number for concurrency control
  870.      *     version_type: enum, // Specific version type
  871.      *     if_seq_no: number, // only perform the index operation if the last operation that has changed the document has the specified sequence number
  872.      *     if_primary_term: number, // only perform the index operation if the last operation that has changed the document has the specified primary term
  873.      *     pipeline: string, // The pipeline id to preprocess incoming documents with
  874.      *     require_alias: boolean, // When true, requires destination to be an alias. Default is false
  875.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  876.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  877.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  878.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  879.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  880.      *     body: array, // (REQUIRED) The document
  881.      * } $params
  882.      *
  883.      * @throws MissingParameterException if a required parameter is missing
  884.      * @throws NoNodeAvailableException if all the hosts are offline
  885.      * @throws ClientResponseException if the status code of response is 4xx
  886.      * @throws ServerResponseException if the status code of response is 5xx
  887.      *
  888.      * @return Elasticsearch|Promise
  889.      */
  890.     public function index(array $params = [])
  891.     {
  892.         $this->checkRequiredParameters(['index','body'], $params);
  893.         if (isset($params['id'])) {
  894.             $url = '/' . $this->encode($params['index']) . '/_doc/' . $this->encode($params['id']);
  895.             $method = 'PUT';
  896.         } else {
  897.             $url = '/' . $this->encode($params['index']) . '/_doc';
  898.             $method = 'POST';
  899.         }
  900.         $url = $this->addQueryString($url, $params, ['wait_for_active_shards','op_type','refresh','routing','timeout','version','version_type','if_seq_no','if_primary_term','pipeline','require_alias','pretty','human','error_trace','source','filter_path']);
  901.         $headers = [
  902.             'Accept' => 'application/json',
  903.             'Content-Type' => 'application/json',
  904.         ];
  905.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  906.     }
  909.     /**
  910.      * Returns basic information about the cluster.
  911.      *
  912.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html
  913.      *
  914.      * @param array{
  915.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  916.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  917.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  918.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  919.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  920.      * } $params
  921.      *
  922.      * @throws NoNodeAvailableException if all the hosts are offline
  923.      * @throws ClientResponseException if the status code of response is 4xx
  924.      * @throws ServerResponseException if the status code of response is 5xx
  925.      *
  926.      * @return Elasticsearch|Promise
  927.      */
  928.     public function info(array $params = [])
  929.     {
  930.         $url = '/';
  931.         $method = 'GET';
  933.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  934.         $headers = [
  935.             'Accept' => 'application/json',
  936.         ];
  937.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  938.     }
  941.     /**
  942.      * Performs a kNN search.
  943.      *
  944.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-search.html
  945.      * @internal This API is EXPERIMENTAL and may be changed or removed completely in a future release
  946.      *
  947.      * @param array{
  948.      *     index: list, // (REQUIRED) A comma-separated list of index names to search; use `_all` to perform the operation on all indices
  949.      *     routing: list, // A comma-separated list of specific routing values
  950.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  951.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  952.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  953.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  954.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  955.      *     body: array, //  The search definition
  956.      * } $params
  957.      *
  958.      * @throws MissingParameterException if a required parameter is missing
  959.      * @throws NoNodeAvailableException if all the hosts are offline
  960.      * @throws ClientResponseException if the status code of response is 4xx
  961.      * @throws ServerResponseException if the status code of response is 5xx
  962.      *
  963.      * @return Elasticsearch|Promise
  964.      */
  965.     public function knnSearch(array $params = [])
  966.     {
  967.         $this->checkRequiredParameters(['index'], $params);
  968.         $url = '/' . $this->encode($params['index']) . '/_knn_search';
  969.         $method = empty($params['body']) ? 'GET' : 'POST';
  971.         $url = $this->addQueryString($url, $params, ['routing','pretty','human','error_trace','source','filter_path']);
  972.         $headers = [
  973.             'Accept' => 'application/json',
  974.             'Content-Type' => 'application/json',
  975.         ];
  976.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  977.     }
  980.     /**
  981.      * Allows to get multiple documents in one request.
  982.      *
  983.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-multi-get.html
  984.      *
  985.      * @param array{
  986.      *     index: string, //  The name of the index
  987.      *     force_synthetic_source: boolean, // Should this request force synthetic _source? Use this to test if the mapping supports synthetic _source and to get a sense of the worst case performance. Fetches with this enabled will be slower the enabling synthetic source natively in the index.
  988.      *     stored_fields: list, // A comma-separated list of stored fields to return in the response
  989.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  990.      *     realtime: boolean, // Specify whether to perform the operation in realtime or search mode
  991.      *     refresh: boolean, // Refresh the shard containing the document before performing the operation
  992.      *     routing: string, // Specific routing value
  993.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  994.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  995.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  996.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  997.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  998.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  999.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1000.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1001.      *     body: array, // (REQUIRED) Document identifiers; can be either `docs` (containing full document information) or `ids` (when index is provided in the URL.
  1002.      * } $params
  1003.      *
  1004.      * @throws NoNodeAvailableException if all the hosts are offline
  1005.      * @throws ClientResponseException if the status code of response is 4xx
  1006.      * @throws ServerResponseException if the status code of response is 5xx
  1007.      *
  1008.      * @return Elasticsearch|Promise
  1009.      */
  1010.     public function mget(array $params = [])
  1011.     {
  1012.         $this->checkRequiredParameters(['body'], $params);
  1013.         if (isset($params['index'])) {
  1014.             $url = '/' . $this->encode($params['index']) . '/_mget';
  1015.             $method = empty($params['body']) ? 'GET' : 'POST';
  1016.         } else {
  1017.             $url = '/_mget';
  1018.             $method = empty($params['body']) ? 'GET' : 'POST';
  1019.         }
  1020.         $url = $this->addQueryString($url, $params, ['force_synthetic_source','stored_fields','preference','realtime','refresh','routing','_source','_source_excludes','_source_includes','pretty','human','error_trace','source','filter_path']);
  1021.         $headers = [
  1022.             'Accept' => 'application/json',
  1023.             'Content-Type' => 'application/json',
  1024.         ];
  1025.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1026.     }
  1029.     /**
  1030.      * Allows to execute several search operations in one request.
  1031.      *
  1032.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-multi-search.html
  1033.      *
  1034.      * @param array{
  1035.      *     index: list, //  A comma-separated list of index names to use as default
  1036.      *     search_type: enum, // Search operation type
  1037.      *     max_concurrent_searches: number, // Controls the maximum number of concurrent searches the multi search api will execute
  1038.      *     typed_keys: boolean, // Specify whether aggregation and suggester names should be prefixed by their respective types in the response
  1039.      *     pre_filter_shard_size: number, // A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on its rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
  1040.      *     max_concurrent_shard_requests: number, // The number of concurrent shard requests each sub search executes concurrently per node. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
  1041.      *     rest_total_hits_as_int: boolean, // Indicates whether hits.total should be rendered as an integer or an object in the rest search response
  1042.      *     ccs_minimize_roundtrips: boolean, // Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution
  1043.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1044.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1045.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1046.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1047.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1048.      *     body: array, // (REQUIRED) The request definitions (metadata-search request definition pairs), separated by newlines
  1049.      * } $params
  1050.      *
  1051.      * @throws NoNodeAvailableException if all the hosts are offline
  1052.      * @throws ClientResponseException if the status code of response is 4xx
  1053.      * @throws ServerResponseException if the status code of response is 5xx
  1054.      *
  1055.      * @return Elasticsearch|Promise
  1056.      */
  1057.     public function msearch(array $params = [])
  1058.     {
  1059.         $this->checkRequiredParameters(['body'], $params);
  1060.         if (isset($params['index'])) {
  1061.             $url = '/' . $this->encode($params['index']) . '/_msearch';
  1062.             $method = empty($params['body']) ? 'GET' : 'POST';
  1063.         } else {
  1064.             $url = '/_msearch';
  1065.             $method = empty($params['body']) ? 'GET' : 'POST';
  1066.         }
  1067.         $url = $this->addQueryString($url, $params, ['search_type','max_concurrent_searches','typed_keys','pre_filter_shard_size','max_concurrent_shard_requests','rest_total_hits_as_int','ccs_minimize_roundtrips','pretty','human','error_trace','source','filter_path']);
  1068.         $headers = [
  1069.             'Accept' => 'application/json',
  1070.             'Content-Type' => 'application/x-ndjson',
  1071.         ];
  1072.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1073.     }
  1076.     /**
  1077.      * Allows to execute several search template operations in one request.
  1078.      *
  1079.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html
  1080.      *
  1081.      * @param array{
  1082.      *     index: list, //  A comma-separated list of index names to use as default
  1083.      *     search_type: enum, // Search operation type
  1084.      *     typed_keys: boolean, // Specify whether aggregation and suggester names should be prefixed by their respective types in the response
  1085.      *     max_concurrent_searches: number, // Controls the maximum number of concurrent searches the multi search api will execute
  1086.      *     rest_total_hits_as_int: boolean, // Indicates whether hits.total should be rendered as an integer or an object in the rest search response
  1087.      *     ccs_minimize_roundtrips: boolean, // Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution
  1088.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1089.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1090.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1091.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1092.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1093.      *     body: array, // (REQUIRED) The request definitions (metadata-search request definition pairs), separated by newlines
  1094.      * } $params
  1095.      *
  1096.      * @throws NoNodeAvailableException if all the hosts are offline
  1097.      * @throws ClientResponseException if the status code of response is 4xx
  1098.      * @throws ServerResponseException if the status code of response is 5xx
  1099.      *
  1100.      * @return Elasticsearch|Promise
  1101.      */
  1102.     public function msearchTemplate(array $params = [])
  1103.     {
  1104.         $this->checkRequiredParameters(['body'], $params);
  1105.         if (isset($params['index'])) {
  1106.             $url = '/' . $this->encode($params['index']) . '/_msearch/template';
  1107.             $method = empty($params['body']) ? 'GET' : 'POST';
  1108.         } else {
  1109.             $url = '/_msearch/template';
  1110.             $method = empty($params['body']) ? 'GET' : 'POST';
  1111.         }
  1112.         $url = $this->addQueryString($url, $params, ['search_type','typed_keys','max_concurrent_searches','rest_total_hits_as_int','ccs_minimize_roundtrips','pretty','human','error_trace','source','filter_path']);
  1113.         $headers = [
  1114.             'Accept' => 'application/json',
  1115.             'Content-Type' => 'application/x-ndjson',
  1116.         ];
  1117.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1118.     }
  1121.     /**
  1122.      * Returns multiple termvectors in one request.
  1123.      *
  1124.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-multi-termvectors.html
  1125.      *
  1126.      * @param array{
  1127.      *     index: string, //  The index in which the document resides.
  1128.      *     ids: list, // A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
  1129.      *     term_statistics: boolean, // Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1130.      *     field_statistics: boolean, // Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1131.      *     fields: list, // A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1132.      *     offsets: boolean, // Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1133.      *     positions: boolean, // Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1134.      *     payloads: boolean, // Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1135.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1136.      *     routing: string, // Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
  1137.      *     realtime: boolean, // Specifies if requests are real-time as opposed to near-real-time (default: true).
  1138.      *     version: number, // Explicit version number for concurrency control
  1139.      *     version_type: enum, // Specific version type
  1140.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1141.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1142.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1143.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1144.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1145.      *     body: array, //  Define ids, documents, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.
  1146.      * } $params
  1147.      *
  1148.      * @throws NoNodeAvailableException if all the hosts are offline
  1149.      * @throws ClientResponseException if the status code of response is 4xx
  1150.      * @throws ServerResponseException if the status code of response is 5xx
  1151.      *
  1152.      * @return Elasticsearch|Promise
  1153.      */
  1154.     public function mtermvectors(array $params = [])
  1155.     {
  1156.         if (isset($params['index'])) {
  1157.             $url = '/' . $this->encode($params['index']) . '/_mtermvectors';
  1158.             $method = empty($params['body']) ? 'GET' : 'POST';
  1159.         } else {
  1160.             $url = '/_mtermvectors';
  1161.             $method = empty($params['body']) ? 'GET' : 'POST';
  1162.         }
  1163.         $url = $this->addQueryString($url, $params, ['ids','term_statistics','field_statistics','fields','offsets','positions','payloads','preference','routing','realtime','version','version_type','pretty','human','error_trace','source','filter_path']);
  1164.         $headers = [
  1165.             'Accept' => 'application/json',
  1166.             'Content-Type' => 'application/json',
  1167.         ];
  1168.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1169.     }
  1172.     /**
  1173.      * Open a point in time that can be used in subsequent searches
  1174.      *
  1175.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/point-in-time-api.html
  1176.      *
  1177.      * @param array{
  1178.      *     index: list, // (REQUIRED) A comma-separated list of index names to open point in time; use `_all` or empty string to perform the operation on all indices
  1179.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  1180.      *     routing: string, // Specific routing value
  1181.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  1182.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  1183.      *     keep_alive: string, // Specific the time to live for the point in time
  1184.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1185.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1186.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1187.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1188.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1189.      * } $params
  1190.      *
  1191.      * @throws MissingParameterException if a required parameter is missing
  1192.      * @throws NoNodeAvailableException if all the hosts are offline
  1193.      * @throws ClientResponseException if the status code of response is 4xx
  1194.      * @throws ServerResponseException if the status code of response is 5xx
  1195.      *
  1196.      * @return Elasticsearch|Promise
  1197.      */
  1198.     public function openPointInTime(array $params = [])
  1199.     {
  1200.         $this->checkRequiredParameters(['index','keep_alive'], $params);
  1201.         $url = '/' . $this->encode($params['index']) . '/_pit';
  1202.         $method = 'POST';
  1204.         $url = $this->addQueryString($url, $params, ['preference','routing','ignore_unavailable','expand_wildcards','keep_alive','pretty','human','error_trace','source','filter_path']);
  1205.         $headers = [
  1206.             'Accept' => 'application/json',
  1207.         ];
  1208.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1209.     }
  1212.     /**
  1213.      * Returns whether the cluster is running.
  1214.      *
  1215.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html
  1216.      *
  1217.      * @param array{
  1218.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1219.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1220.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1221.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1222.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1223.      * } $params
  1224.      *
  1225.      * @throws NoNodeAvailableException if all the hosts are offline
  1226.      * @throws ClientResponseException if the status code of response is 4xx
  1227.      * @throws ServerResponseException if the status code of response is 5xx
  1228.      *
  1229.      * @return Elasticsearch|Promise
  1230.      */
  1231.     public function ping(array $params = [])
  1232.     {
  1233.         $url = '/';
  1234.         $method = 'HEAD';
  1236.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  1237.         $headers = [
  1238.             'Accept' => 'application/json',
  1239.         ];
  1240.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1241.     }
  1244.     /**
  1245.      * Creates or updates a script.
  1246.      *
  1247.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html
  1248.      *
  1249.      * @param array{
  1250.      *     id: string, // (REQUIRED) Script ID
  1251.      *     context: string, //  Script context
  1252.      *     timeout: time, // Explicit operation timeout
  1253.      *     master_timeout: time, // Specify timeout for connection to master
  1254.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1255.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1256.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1257.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1258.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1259.      *     body: array, // (REQUIRED) The document
  1260.      * } $params
  1261.      *
  1262.      * @throws MissingParameterException if a required parameter is missing
  1263.      * @throws NoNodeAvailableException if all the hosts are offline
  1264.      * @throws ClientResponseException if the status code of response is 4xx
  1265.      * @throws ServerResponseException if the status code of response is 5xx
  1266.      *
  1267.      * @return Elasticsearch|Promise
  1268.      */
  1269.     public function putScript(array $params = [])
  1270.     {
  1271.         $this->checkRequiredParameters(['id','body'], $params);
  1272.         if (isset($params['context'])) {
  1273.             $url = '/_scripts/' . $this->encode($params['id']) . '/' . $this->encode($params['context']);
  1274.             $method = 'PUT';
  1275.         } else {
  1276.             $url = '/_scripts/' . $this->encode($params['id']);
  1277.             $method = 'PUT';
  1278.         }
  1279.         $url = $this->addQueryString($url, $params, ['timeout','master_timeout','pretty','human','error_trace','source','filter_path']);
  1280.         $headers = [
  1281.             'Accept' => 'application/json',
  1282.             'Content-Type' => 'application/json',
  1283.         ];
  1284.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1285.     }
  1288.     /**
  1289.      * Allows to evaluate the quality of ranked search results over a set of typical search queries
  1290.      *
  1291.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-rank-eval.html
  1292.      *
  1293.      * @param array{
  1294.      *     index: list, //  A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  1295.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  1296.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  1297.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  1298.      *     search_type: enum, // Search operation type
  1299.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1300.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1301.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1302.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1303.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1304.      *     body: array, // (REQUIRED) The ranking evaluation search definition, including search requests, document ratings and ranking metric definition.
  1305.      * } $params
  1306.      *
  1307.      * @throws NoNodeAvailableException if all the hosts are offline
  1308.      * @throws ClientResponseException if the status code of response is 4xx
  1309.      * @throws ServerResponseException if the status code of response is 5xx
  1310.      *
  1311.      * @return Elasticsearch|Promise
  1312.      */
  1313.     public function rankEval(array $params = [])
  1314.     {
  1315.         $this->checkRequiredParameters(['body'], $params);
  1316.         if (isset($params['index'])) {
  1317.             $url = '/' . $this->encode($params['index']) . '/_rank_eval';
  1318.             $method = empty($params['body']) ? 'GET' : 'POST';
  1319.         } else {
  1320.             $url = '/_rank_eval';
  1321.             $method = empty($params['body']) ? 'GET' : 'POST';
  1322.         }
  1323.         $url = $this->addQueryString($url, $params, ['ignore_unavailable','allow_no_indices','expand_wildcards','search_type','pretty','human','error_trace','source','filter_path']);
  1324.         $headers = [
  1325.             'Accept' => 'application/json',
  1326.             'Content-Type' => 'application/json',
  1327.         ];
  1328.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1329.     }
  1332.     /**
  1333.      * Allows to copy documents from one index to another, optionally filtering the source
  1334.      * documents by a query, changing the destination index settings, or fetching the
  1335.      * documents from a remote cluster.
  1336.      *
  1337.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html
  1338.      *
  1339.      * @param array{
  1340.      *     refresh: boolean, // Should the affected indexes be refreshed?
  1341.      *     timeout: time, // Time each individual bulk request should wait for shards that are unavailable.
  1342.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  1343.      *     wait_for_completion: boolean, // Should the request should block until the reindex is complete.
  1344.      *     requests_per_second: number, // The throttle to set on this request in sub-requests per second. -1 means no throttle.
  1345.      *     scroll: time, // Control how long to keep the search context alive
  1346.      *     slices: number|string, // The number of slices this task should be divided into. Defaults to 1, meaning the task isn't sliced into subtasks. Can be set to `auto`.
  1347.      *     max_docs: number, // Maximum number of documents to process (default: all documents)
  1348.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1349.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1350.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1351.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1352.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1353.      *     body: array, // (REQUIRED) The search definition using the Query DSL and the prototype for the index request.
  1354.      * } $params
  1355.      *
  1356.      * @throws NoNodeAvailableException if all the hosts are offline
  1357.      * @throws ClientResponseException if the status code of response is 4xx
  1358.      * @throws ServerResponseException if the status code of response is 5xx
  1359.      *
  1360.      * @return Elasticsearch|Promise
  1361.      */
  1362.     public function reindex(array $params = [])
  1363.     {
  1364.         $this->checkRequiredParameters(['body'], $params);
  1365.         $url = '/_reindex';
  1366.         $method = 'POST';
  1368.         $url = $this->addQueryString($url, $params, ['refresh','timeout','wait_for_active_shards','wait_for_completion','requests_per_second','scroll','slices','max_docs','pretty','human','error_trace','source','filter_path']);
  1369.         $headers = [
  1370.             'Accept' => 'application/json',
  1371.             'Content-Type' => 'application/json',
  1372.         ];
  1373.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1374.     }
  1377.     /**
  1378.      * Changes the number of requests per second for a particular Reindex operation.
  1379.      *
  1380.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html
  1381.      *
  1382.      * @param array{
  1383.      *     task_id: string, // (REQUIRED) The task id to rethrottle
  1384.      *     requests_per_second: number, // The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
  1385.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1386.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1387.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1388.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1389.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1390.      * } $params
  1391.      *
  1392.      * @throws MissingParameterException if a required parameter is missing
  1393.      * @throws NoNodeAvailableException if all the hosts are offline
  1394.      * @throws ClientResponseException if the status code of response is 4xx
  1395.      * @throws ServerResponseException if the status code of response is 5xx
  1396.      *
  1397.      * @return Elasticsearch|Promise
  1398.      */
  1399.     public function reindexRethrottle(array $params = [])
  1400.     {
  1401.         $this->checkRequiredParameters(['task_id','requests_per_second'], $params);
  1402.         $url = '/_reindex/' . $this->encode($params['task_id']) . '/_rethrottle';
  1403.         $method = 'POST';
  1405.         $url = $this->addQueryString($url, $params, ['requests_per_second','pretty','human','error_trace','source','filter_path']);
  1406.         $headers = [
  1407.             'Accept' => 'application/json',
  1408.         ];
  1409.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1410.     }
  1413.     /**
  1414.      * Allows to use the Mustache language to pre-render a search definition.
  1415.      *
  1416.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/render-search-template-api.html
  1417.      *
  1418.      * @param array{
  1419.      *     id: string, //  The id of the stored search template
  1420.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1421.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1422.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1423.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1424.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1425.      *     body: array, //  The search definition template and its params
  1426.      * } $params
  1427.      *
  1428.      * @throws NoNodeAvailableException if all the hosts are offline
  1429.      * @throws ClientResponseException if the status code of response is 4xx
  1430.      * @throws ServerResponseException if the status code of response is 5xx
  1431.      *
  1432.      * @return Elasticsearch|Promise
  1433.      */
  1434.     public function renderSearchTemplate(array $params = [])
  1435.     {
  1436.         if (isset($params['id'])) {
  1437.             $url = '/_render/template/' . $this->encode($params['id']);
  1438.             $method = empty($params['body']) ? 'GET' : 'POST';
  1439.         } else {
  1440.             $url = '/_render/template';
  1441.             $method = empty($params['body']) ? 'GET' : 'POST';
  1442.         }
  1443.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  1444.         $headers = [
  1445.             'Accept' => 'application/json',
  1446.             'Content-Type' => 'application/json',
  1447.         ];
  1448.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1449.     }
  1452.     /**
  1453.      * Allows an arbitrary script to be executed and a result to be returned
  1454.      *
  1455.      * @see https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-execute-api.html
  1456.      * @internal This API is EXPERIMENTAL and may be changed or removed completely in a future release
  1457.      *
  1458.      * @param array{
  1459.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1460.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1461.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1462.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1463.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1464.      *     body: array, //  The script to execute
  1465.      * } $params
  1466.      *
  1467.      * @throws NoNodeAvailableException if all the hosts are offline
  1468.      * @throws ClientResponseException if the status code of response is 4xx
  1469.      * @throws ServerResponseException if the status code of response is 5xx
  1470.      *
  1471.      * @return Elasticsearch|Promise
  1472.      */
  1473.     public function scriptsPainlessExecute(array $params = [])
  1474.     {
  1475.         $url = '/_scripts/painless/_execute';
  1476.         $method = empty($params['body']) ? 'GET' : 'POST';
  1478.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  1479.         $headers = [
  1480.             'Accept' => 'application/json',
  1481.             'Content-Type' => 'application/json',
  1482.         ];
  1483.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1484.     }
  1487.     /**
  1488.      * Allows to retrieve a large numbers of results from a single search request.
  1489.      *
  1490.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-request-body.html#request-body-search-scroll
  1491.      *
  1492.      * @param array{
  1493.      *     scroll_id: string, //  The scroll ID
  1494.      *     scroll: time, // Specify how long a consistent view of the index should be maintained for scrolled search
  1495.      *     rest_total_hits_as_int: boolean, // Indicates whether hits.total should be rendered as an integer or an object in the rest search response
  1496.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1497.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1498.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1499.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1500.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1501.      *     body: array, //  The scroll ID if not passed by URL or query parameter.
  1502.      * } $params
  1503.      *
  1504.      * @throws NoNodeAvailableException if all the hosts are offline
  1505.      * @throws ClientResponseException if the status code of response is 4xx
  1506.      * @throws ServerResponseException if the status code of response is 5xx
  1507.      *
  1508.      * @return Elasticsearch|Promise
  1509.      */
  1510.     public function scroll(array $params = [])
  1511.     {
  1512.         if (isset($params['scroll_id'])) {
  1513.             $url = '/_search/scroll/' . $this->encode($params['scroll_id']);
  1514.             $method = empty($params['body']) ? 'GET' : 'POST';
  1515.         } else {
  1516.             $url = '/_search/scroll';
  1517.             $method = empty($params['body']) ? 'GET' : 'POST';
  1518.         }
  1519.         $url = $this->addQueryString($url, $params, ['scroll','rest_total_hits_as_int','pretty','human','error_trace','source','filter_path']);
  1520.         $headers = [
  1521.             'Accept' => 'application/json',
  1522.             'Content-Type' => 'application/json',
  1523.         ];
  1524.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1525.     }
  1528.     /**
  1529.      * Returns results matching a query.
  1530.      *
  1531.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-search.html
  1532.      *
  1533.      * @param array{
  1534.      *     index: list, //  A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  1535.      *     analyzer: string, // The analyzer to use for the query string
  1536.      *     analyze_wildcard: boolean, // Specify whether wildcard and prefix queries should be analyzed (default: false)
  1537.      *     ccs_minimize_roundtrips: boolean, // Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution
  1538.      *     default_operator: enum, // The default operator for query string query (AND or OR)
  1539.      *     df: string, // The field to use as default where no field prefix is given in the query string
  1540.      *     explain: boolean, // Specify whether to return detailed information about score computation as part of a hit
  1541.      *     stored_fields: list, // A comma-separated list of stored fields to return as part of a hit
  1542.      *     docvalue_fields: list, // A comma-separated list of fields to return as the docvalue representation of a field for each hit
  1543.      *     from: number, // Starting offset (default: 0)
  1544.      *     force_synthetic_source: boolean, // Should this request force synthetic _source? Use this to test if the mapping supports synthetic _source and to get a sense of the worst case performance. Fetches with this enabled will be slower the enabling synthetic source natively in the index.
  1545.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  1546.      *     ignore_throttled: boolean, // Whether specified concrete, expanded or aliased indices should be ignored when throttled
  1547.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  1548.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  1549.      *     lenient: boolean, // Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
  1550.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  1551.      *     q: string, // Query in the Lucene query string syntax
  1552.      *     routing: list, // A comma-separated list of specific routing values
  1553.      *     scroll: time, // Specify how long a consistent view of the index should be maintained for scrolled search
  1554.      *     search_type: enum, // Search operation type
  1555.      *     size: number, // Number of hits to return (default: 10)
  1556.      *     sort: list, // A comma-separated list of <field>:<direction> pairs
  1557.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  1558.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  1559.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  1560.      *     terminate_after: number, // The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
  1561.      *     stats: list, // Specific 'tag' of the request for logging and statistical purposes
  1562.      *     suggest_field: string, // Specify which field to use for suggestions
  1563.      *     suggest_mode: enum, // Specify suggest mode
  1564.      *     suggest_size: number, // How many suggestions to return in response
  1565.      *     suggest_text: string, // The source text for which the suggestions should be returned
  1566.      *     timeout: time, // Explicit operation timeout
  1567.      *     track_scores: boolean, // Whether to calculate and return scores even if they are not used for sorting
  1568.      *     track_total_hits: boolean|long, // Indicate if the number of documents that match the query should be tracked. A number can also be specified, to accurately track the total hit count up to the number.
  1569.      *     allow_partial_search_results: boolean, // Indicate if an error should be returned if there is a partial search failure or timeout
  1570.      *     typed_keys: boolean, // Specify whether aggregation and suggester names should be prefixed by their respective types in the response
  1571.      *     version: boolean, // Specify whether to return document version as part of a hit
  1572.      *     seq_no_primary_term: boolean, // Specify whether to return sequence number and primary term of the last modification of each hit
  1573.      *     request_cache: boolean, // Specify if request cache should be used for this request or not, defaults to index level setting
  1574.      *     batched_reduce_size: number, // The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
  1575.      *     max_concurrent_shard_requests: number, // The number of concurrent shard requests per node this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
  1576.      *     pre_filter_shard_size: number, // A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on its rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
  1577.      *     rest_total_hits_as_int: boolean, // Indicates whether hits.total should be rendered as an integer or an object in the rest search response
  1578.      *     min_compatible_shard_node: string, // The minimum compatible version that all shards involved in search should have for this request to be successful
  1579.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1580.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1581.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1582.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1583.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1584.      *     body: array, //  The search definition using the Query DSL
  1585.      * } $params
  1586.      *
  1587.      * @throws NoNodeAvailableException if all the hosts are offline
  1588.      * @throws ClientResponseException if the status code of response is 4xx
  1589.      * @throws ServerResponseException if the status code of response is 5xx
  1590.      *
  1591.      * @return Elasticsearch|Promise
  1592.      */
  1593.     public function search(array $params = [])
  1594.     {
  1595.         if (isset($params['index'])) {
  1596.             $url = '/' . $this->encode($params['index']) . '/_search';
  1597.             $method = empty($params['body']) ? 'GET' : 'POST';
  1598.         } else {
  1599.             $url = '/_search';
  1600.             $method = empty($params['body']) ? 'GET' : 'POST';
  1601.         }
  1602.         $url = $this->addQueryString($url, $params, ['analyzer','analyze_wildcard','ccs_minimize_roundtrips','default_operator','df','explain','stored_fields','docvalue_fields','from','force_synthetic_source','ignore_unavailable','ignore_throttled','allow_no_indices','expand_wildcards','lenient','preference','q','routing','scroll','search_type','size','sort','_source','_source_excludes','_source_includes','terminate_after','stats','suggest_field','suggest_mode','suggest_size','suggest_text','timeout','track_scores','track_total_hits','allow_partial_search_results','typed_keys','version','seq_no_primary_term','request_cache','batched_reduce_size','max_concurrent_shard_requests','pre_filter_shard_size','rest_total_hits_as_int','min_compatible_shard_node','pretty','human','error_trace','source','filter_path']);
  1603.         $headers = [
  1604.             'Accept' => 'application/json',
  1605.             'Content-Type' => 'application/json',
  1606.         ];
  1607.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1608.     }
  1611.     /**
  1612.      * Searches a vector tile for geospatial values. Returns results as a binary Mapbox vector tile.
  1613.      *
  1614.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-vector-tile-api.html
  1615.      * @internal This API is EXPERIMENTAL and may be changed or removed completely in a future release
  1616.      *
  1617.      * @param array{
  1618.      *     index: list, // (REQUIRED) Comma-separated list of data streams, indices, or aliases to search
  1619.      *     field: string, // (REQUIRED) Field containing geospatial data to return
  1620.      *     zoom: int, // (REQUIRED) Zoom level for the vector tile to search
  1621.      *     x: int, // (REQUIRED) X coordinate for the vector tile to search
  1622.      *     y: int, // (REQUIRED) Y coordinate for the vector tile to search
  1623.      *     exact_bounds: boolean, // If false, the meta layer's feature is the bounding box of the tile. If true, the meta layer's feature is a bounding box resulting from a `geo_bounds` aggregation.
  1624.      *     extent: int, // Size, in pixels, of a side of the vector tile.
  1625.      *     grid_precision: int, // Additional zoom levels available through the aggs layer. Accepts 0-8.
  1626.      *     grid_type: enum, // Determines the geometry type for features in the aggs layer.
  1627.      *     size: int, // Maximum number of features to return in the hits layer. Accepts 0-10000.
  1628.      *     track_total_hits: boolean|long, // Indicate if the number of documents that match the query should be tracked. A number can also be specified, to accurately track the total hit count up to the number.
  1629.      *     with_labels: boolean, // If true, the hits and aggs layers will contain additional point features with suggested label positions for the original features.
  1630.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1631.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1632.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1633.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1634.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1635.      *     body: array, //  Search request body.
  1636.      * } $params
  1637.      *
  1638.      * @throws MissingParameterException if a required parameter is missing
  1639.      * @throws NoNodeAvailableException if all the hosts are offline
  1640.      * @throws ClientResponseException if the status code of response is 4xx
  1641.      * @throws ServerResponseException if the status code of response is 5xx
  1642.      *
  1643.      * @return Elasticsearch|Promise
  1644.      */
  1645.     public function searchMvt(array $params = [])
  1646.     {
  1647.         $this->checkRequiredParameters(['index','field','zoom','x','y'], $params);
  1648.         $url = '/' . $this->encode($params['index']) . '/_mvt/' . $this->encode($params['field']) . '/' . $this->encode($params['zoom']) . '/' . $this->encode($params['x']) . '/' . $this->encode($params['y']);
  1649.         $method = empty($params['body']) ? 'GET' : 'POST';
  1651.         $url = $this->addQueryString($url, $params, ['exact_bounds','extent','grid_precision','grid_type','size','track_total_hits','with_labels','pretty','human','error_trace','source','filter_path']);
  1652.         $headers = [
  1653.             'Accept' => 'application/vnd.mapbox-vector-tile',
  1654.             'Content-Type' => 'application/json',
  1655.         ];
  1656.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1657.     }
  1660.     /**
  1661.      * Returns information about the indices and shards that a search request would be executed against.
  1662.      *
  1663.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-shards.html
  1664.      *
  1665.      * @param array{
  1666.      *     index: list, //  A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  1667.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  1668.      *     routing: string, // Specific routing value
  1669.      *     local: boolean, // Return local information, do not retrieve the state from master node (default: false)
  1670.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  1671.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  1672.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  1673.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1674.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1675.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1676.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1677.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1678.      * } $params
  1679.      *
  1680.      * @throws NoNodeAvailableException if all the hosts are offline
  1681.      * @throws ClientResponseException if the status code of response is 4xx
  1682.      * @throws ServerResponseException if the status code of response is 5xx
  1683.      *
  1684.      * @return Elasticsearch|Promise
  1685.      */
  1686.     public function searchShards(array $params = [])
  1687.     {
  1688.         if (isset($params['index'])) {
  1689.             $url = '/' . $this->encode($params['index']) . '/_search_shards';
  1690.             $method = empty($params['body']) ? 'GET' : 'POST';
  1691.         } else {
  1692.             $url = '/_search_shards';
  1693.             $method = empty($params['body']) ? 'GET' : 'POST';
  1694.         }
  1695.         $url = $this->addQueryString($url, $params, ['preference','routing','local','ignore_unavailable','allow_no_indices','expand_wildcards','pretty','human','error_trace','source','filter_path']);
  1696.         $headers = [
  1697.             'Accept' => 'application/json',
  1698.         ];
  1699.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1700.     }
  1703.     /**
  1704.      * Allows to use the Mustache language to pre-render a search definition.
  1705.      *
  1706.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html
  1707.      *
  1708.      * @param array{
  1709.      *     index: list, //  A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  1710.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  1711.      *     ignore_throttled: boolean, // Whether specified concrete, expanded or aliased indices should be ignored when throttled
  1712.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  1713.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  1714.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  1715.      *     routing: list, // A comma-separated list of specific routing values
  1716.      *     scroll: time, // Specify how long a consistent view of the index should be maintained for scrolled search
  1717.      *     search_type: enum, // Search operation type
  1718.      *     explain: boolean, // Specify whether to return detailed information about score computation as part of a hit
  1719.      *     profile: boolean, // Specify whether to profile the query execution
  1720.      *     typed_keys: boolean, // Specify whether aggregation and suggester names should be prefixed by their respective types in the response
  1721.      *     rest_total_hits_as_int: boolean, // Indicates whether hits.total should be rendered as an integer or an object in the rest search response
  1722.      *     ccs_minimize_roundtrips: boolean, // Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution
  1723.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1724.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1725.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1726.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1727.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1728.      *     body: array, // (REQUIRED) The search definition template and its params
  1729.      * } $params
  1730.      *
  1731.      * @throws NoNodeAvailableException if all the hosts are offline
  1732.      * @throws ClientResponseException if the status code of response is 4xx
  1733.      * @throws ServerResponseException if the status code of response is 5xx
  1734.      *
  1735.      * @return Elasticsearch|Promise
  1736.      */
  1737.     public function searchTemplate(array $params = [])
  1738.     {
  1739.         $this->checkRequiredParameters(['body'], $params);
  1740.         if (isset($params['index'])) {
  1741.             $url = '/' . $this->encode($params['index']) . '/_search/template';
  1742.             $method = empty($params['body']) ? 'GET' : 'POST';
  1743.         } else {
  1744.             $url = '/_search/template';
  1745.             $method = empty($params['body']) ? 'GET' : 'POST';
  1746.         }
  1747.         $url = $this->addQueryString($url, $params, ['ignore_unavailable','ignore_throttled','allow_no_indices','expand_wildcards','preference','routing','scroll','search_type','explain','profile','typed_keys','rest_total_hits_as_int','ccs_minimize_roundtrips','pretty','human','error_trace','source','filter_path']);
  1748.         $headers = [
  1749.             'Accept' => 'application/json',
  1750.             'Content-Type' => 'application/json',
  1751.         ];
  1752.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1753.     }
  1756.     /**
  1757.      * The terms enum API  can be used to discover terms in the index that begin with the provided string. It is designed for low-latency look-ups used in auto-complete scenarios.
  1758.      *
  1759.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-terms-enum.html
  1760.      *
  1761.      * @param array{
  1762.      *     index: list, // (REQUIRED) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  1763.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1764.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1765.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1766.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1767.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1768.      *     body: array, //  field name, string which is the prefix expected in matching terms, timeout and size for max number of results
  1769.      * } $params
  1770.      *
  1771.      * @throws MissingParameterException if a required parameter is missing
  1772.      * @throws NoNodeAvailableException if all the hosts are offline
  1773.      * @throws ClientResponseException if the status code of response is 4xx
  1774.      * @throws ServerResponseException if the status code of response is 5xx
  1775.      *
  1776.      * @return Elasticsearch|Promise
  1777.      */
  1778.     public function termsEnum(array $params = [])
  1779.     {
  1780.         $this->checkRequiredParameters(['index'], $params);
  1781.         $url = '/' . $this->encode($params['index']) . '/_terms_enum';
  1782.         $method = empty($params['body']) ? 'GET' : 'POST';
  1784.         $url = $this->addQueryString($url, $params, ['pretty','human','error_trace','source','filter_path']);
  1785.         $headers = [
  1786.             'Accept' => 'application/json',
  1787.             'Content-Type' => 'application/json',
  1788.         ];
  1789.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1790.     }
  1793.     /**
  1794.      * Returns information and statistics about terms in the fields of a particular document.
  1795.      *
  1796.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-termvectors.html
  1797.      *
  1798.      * @param array{
  1799.      *     index: string, // (REQUIRED) The index in which the document resides.
  1800.      *     id: string, //  The id of the document, when not specified a doc param should be supplied.
  1801.      *     term_statistics: boolean, // Specifies if total term frequency and document frequency should be returned.
  1802.      *     field_statistics: boolean, // Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
  1803.      *     fields: list, // A comma-separated list of fields to return.
  1804.      *     offsets: boolean, // Specifies if term offsets should be returned.
  1805.      *     positions: boolean, // Specifies if term positions should be returned.
  1806.      *     payloads: boolean, // Specifies if term payloads should be returned.
  1807.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random).
  1808.      *     routing: string, // Specific routing value.
  1809.      *     realtime: boolean, // Specifies if request is real-time as opposed to near-real-time (default: true).
  1810.      *     version: number, // Explicit version number for concurrency control
  1811.      *     version_type: enum, // Specific version type
  1812.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1813.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1814.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1815.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1816.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1817.      *     body: array, //  Define parameters and or supply a document to get termvectors for. See documentation.
  1818.      * } $params
  1819.      *
  1820.      * @throws MissingParameterException if a required parameter is missing
  1821.      * @throws NoNodeAvailableException if all the hosts are offline
  1822.      * @throws ClientResponseException if the status code of response is 4xx
  1823.      * @throws ServerResponseException if the status code of response is 5xx
  1824.      *
  1825.      * @return Elasticsearch|Promise
  1826.      */
  1827.     public function termvectors(array $params = [])
  1828.     {
  1829.         $this->checkRequiredParameters(['index'], $params);
  1830.         if (isset($params['id'])) {
  1831.             $url = '/' . $this->encode($params['index']) . '/_termvectors/' . $this->encode($params['id']);
  1832.             $method = empty($params['body']) ? 'GET' : 'POST';
  1833.         } else {
  1834.             $url = '/' . $this->encode($params['index']) . '/_termvectors';
  1835.             $method = empty($params['body']) ? 'GET' : 'POST';
  1836.         }
  1837.         $url = $this->addQueryString($url, $params, ['term_statistics','field_statistics','fields','offsets','positions','payloads','preference','routing','realtime','version','version_type','pretty','human','error_trace','source','filter_path']);
  1838.         $headers = [
  1839.             'Accept' => 'application/json',
  1840.             'Content-Type' => 'application/json',
  1841.         ];
  1842.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1843.     }
  1846.     /**
  1847.      * Updates a document with a script or partial document.
  1848.      *
  1849.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-update.html
  1850.      *
  1851.      * @param array{
  1852.      *     id: string, // (REQUIRED) Document ID
  1853.      *     index: string, // (REQUIRED) The name of the index
  1854.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  1855.      *     _source: list, // True or false to return the _source field or not, or a list of fields to return
  1856.      *     _source_excludes: list, // A list of fields to exclude from the returned _source field
  1857.      *     _source_includes: list, // A list of fields to extract and return from the _source field
  1858.      *     lang: string, // The script language (default: painless)
  1859.      *     refresh: enum, // If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
  1860.      *     retry_on_conflict: number, // Specify how many times should the operation be retried when a conflict occurs (default: 0)
  1861.      *     routing: string, // Specific routing value
  1862.      *     timeout: time, // Explicit operation timeout
  1863.      *     if_seq_no: number, // only perform the update operation if the last operation that has changed the document has the specified sequence number
  1864.      *     if_primary_term: number, // only perform the update operation if the last operation that has changed the document has the specified primary term
  1865.      *     require_alias: boolean, // When true, requires destination is an alias. Default is false
  1866.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1867.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1868.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1869.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1870.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1871.      *     body: array, // (REQUIRED) The request definition requires either `script` or partial `doc`
  1872.      * } $params
  1873.      *
  1874.      * @throws MissingParameterException if a required parameter is missing
  1875.      * @throws NoNodeAvailableException if all the hosts are offline
  1876.      * @throws ClientResponseException if the status code of response is 4xx
  1877.      * @throws ServerResponseException if the status code of response is 5xx
  1878.      *
  1879.      * @return Elasticsearch|Promise
  1880.      */
  1881.     public function update(array $params = [])
  1882.     {
  1883.         $this->checkRequiredParameters(['id','index','body'], $params);
  1884.         $url = '/' . $this->encode($params['index']) . '/_update/' . $this->encode($params['id']);
  1885.         $method = 'POST';
  1887.         $url = $this->addQueryString($url, $params, ['wait_for_active_shards','_source','_source_excludes','_source_includes','lang','refresh','retry_on_conflict','routing','timeout','if_seq_no','if_primary_term','require_alias','pretty','human','error_trace','source','filter_path']);
  1888.         $headers = [
  1889.             'Accept' => 'application/json',
  1890.             'Content-Type' => 'application/json',
  1891.         ];
  1892.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1893.     }
  1896.     /**
  1897.      * Performs an update on every document in the index without changing the source,
  1898.      * for example to pick up a mapping change.
  1899.      *
  1900.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-update-by-query.html
  1901.      *
  1902.      * @param array{
  1903.      *     index: list, // (REQUIRED) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
  1904.      *     analyzer: string, // The analyzer to use for the query string
  1905.      *     analyze_wildcard: boolean, // Specify whether wildcard and prefix queries should be analyzed (default: false)
  1906.      *     default_operator: enum, // The default operator for query string query (AND or OR)
  1907.      *     df: string, // The field to use as default where no field prefix is given in the query string
  1908.      *     from: number, // Starting offset (default: 0)
  1909.      *     ignore_unavailable: boolean, // Whether specified concrete indices should be ignored when unavailable (missing or closed)
  1910.      *     allow_no_indices: boolean, // Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  1911.      *     conflicts: enum, // What to do when the update by query hits version conflicts?
  1912.      *     expand_wildcards: enum, // Whether to expand wildcard expression to concrete indices that are open, closed or both.
  1913.      *     lenient: boolean, // Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
  1914.      *     pipeline: string, // Ingest pipeline to set on index requests made by this action. (default: none)
  1915.      *     preference: string, // Specify the node or shard the operation should be performed on (default: random)
  1916.      *     q: string, // Query in the Lucene query string syntax
  1917.      *     routing: list, // A comma-separated list of specific routing values
  1918.      *     scroll: time, // Specify how long a consistent view of the index should be maintained for scrolled search
  1919.      *     search_type: enum, // Search operation type
  1920.      *     search_timeout: time, // Explicit timeout for each search request. Defaults to no timeout.
  1921.      *     max_docs: number, // Maximum number of documents to process (default: all documents)
  1922.      *     sort: list, // A comma-separated list of <field>:<direction> pairs
  1923.      *     terminate_after: number, // The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
  1924.      *     stats: list, // Specific 'tag' of the request for logging and statistical purposes
  1925.      *     version: boolean, // Specify whether to return document version as part of a hit
  1926.      *     version_type: boolean, // Should the document increment the version number (internal) on hit or not (reindex)
  1927.      *     request_cache: boolean, // Specify if request cache should be used for this request or not, defaults to index level setting
  1928.      *     refresh: boolean, // Should the affected indexes be refreshed?
  1929.      *     timeout: time, // Time each individual bulk request should wait for shards that are unavailable.
  1930.      *     wait_for_active_shards: string, // Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
  1931.      *     scroll_size: number, // Size on the scroll request powering the update by query
  1932.      *     wait_for_completion: boolean, // Should the request should block until the update by query operation is complete.
  1933.      *     requests_per_second: number, // The throttle to set on this request in sub-requests per second. -1 means no throttle.
  1934.      *     slices: number|string, // The number of slices this task should be divided into. Defaults to 1, meaning the task isn't sliced into subtasks. Can be set to `auto`.
  1935.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1936.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1937.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1938.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1939.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1940.      *     body: array, //  The search definition using the Query DSL
  1941.      * } $params
  1942.      *
  1943.      * @throws MissingParameterException if a required parameter is missing
  1944.      * @throws NoNodeAvailableException if all the hosts are offline
  1945.      * @throws ClientResponseException if the status code of response is 4xx
  1946.      * @throws ServerResponseException if the status code of response is 5xx
  1947.      *
  1948.      * @return Elasticsearch|Promise
  1949.      */
  1950.     public function updateByQuery(array $params = [])
  1951.     {
  1952.         $this->checkRequiredParameters(['index'], $params);
  1953.         $url = '/' . $this->encode($params['index']) . '/_update_by_query';
  1954.         $method = 'POST';
  1956.         $url = $this->addQueryString($url, $params, ['analyzer','analyze_wildcard','default_operator','df','from','ignore_unavailable','allow_no_indices','conflicts','expand_wildcards','lenient','pipeline','preference','q','routing','scroll','search_type','search_timeout','max_docs','sort','terminate_after','stats','version','version_type','request_cache','refresh','timeout','wait_for_active_shards','scroll_size','wait_for_completion','requests_per_second','slices','pretty','human','error_trace','source','filter_path']);
  1957.         $headers = [
  1958.             'Accept' => 'application/json',
  1959.             'Content-Type' => 'application/json',
  1960.         ];
  1961.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1962.     }
  1965.     /**
  1966.      * Changes the number of requests per second for a particular Update By Query operation.
  1967.      *
  1968.      * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-update-by-query.html
  1969.      *
  1970.      * @param array{
  1971.      *     task_id: string, // (REQUIRED) The task id to rethrottle
  1972.      *     requests_per_second: number, // The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
  1973.      *     pretty: boolean, // Pretty format the returned JSON response. (DEFAULT: false)
  1974.      *     human: boolean, // Return human readable values for statistics. (DEFAULT: true)
  1975.      *     error_trace: boolean, // Include the stack trace of returned errors. (DEFAULT: false)
  1976.      *     source: string, // The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
  1977.      *     filter_path: list, // A comma-separated list of filters used to reduce the response.
  1978.      * } $params
  1979.      *
  1980.      * @throws MissingParameterException if a required parameter is missing
  1981.      * @throws NoNodeAvailableException if all the hosts are offline
  1982.      * @throws ClientResponseException if the status code of response is 4xx
  1983.      * @throws ServerResponseException if the status code of response is 5xx
  1984.      *
  1985.      * @return Elasticsearch|Promise
  1986.      */
  1987.     public function updateByQueryRethrottle(array $params = [])
  1988.     {
  1989.         $this->checkRequiredParameters(['task_id','requests_per_second'], $params);
  1990.         $url = '/_update_by_query/' . $this->encode($params['task_id']) . '/_rethrottle';
  1991.         $method = 'POST';
  1993.         $url = $this->addQueryString($url, $params, ['requests_per_second','pretty','human','error_trace','source','filter_path']);
  1994.         $headers = [
  1995.             'Accept' => 'application/json',
  1996.         ];
  1997.         return $this->sendRequest($this->createRequest($method, $url, $headers, $params['body'] ?? null));
  1998.     }
  1999. }