elasticsearch-serverless 0.5.0 → 0.7.0

data/lib/elasticsearch-serverless/api/open_point_in_time.rb

@@ -21,33 +21,55 @@
 module ElasticsearchServerless
   module API
     module Actions
-      # A search request by default executes against the most recent visible data of the target indices,
+      # Open a point in time.
+      # A search request by default runs against the most recent visible data of the target indices,
       # which is called point in time. Elasticsearch pit (point in time) is a lightweight view into the
       # state of the data as it existed when initiated. In some cases, it’s preferred to perform multiple
       # search requests using the same point in time. For example, if refreshes happen between
       # +search_after+ requests, then the results of those requests might not be consistent as changes happening
       # between searches are only visible to the more recent point in time.
+      # A point in time must be opened explicitly before being used in search requests.
+      # A subsequent search request with the +pit+ parameter must not specify +index+, +routing+, or +preference+ values as these parameters are copied from the point in time.
+      # Just like regular searches, you can use +from+ and +size+ to page through point in time search results, up to the first 10,000 hits.
+      # If you want to retrieve more hits, use PIT with +search_after+.
+      # IMPORTANT: The open point in time request and each subsequent search request can return different identifiers; always use the most recently received ID for the next search request.
+      # When a PIT that contains shard failures is used in a search request, the missing are always reported in the search response as a +NoShardAvailableActionException+ exception.
+      # To get rid of these exceptions, a new PIT needs to be created so that shards missing from the previous PIT can be handled, assuming they become available in the meantime.
+      # **Keeping point in time alive**
+      # The +keep_alive+ parameter, which is passed to a open point in time request and search request, extends the time to live of the corresponding point in time.
+      # The value does not need to be long enough to process all data — it just needs to be long enough for the next request.
+      # Normally, the background merge process optimizes the index by merging together smaller segments to create new, bigger segments.
+      # Once the smaller segments are no longer needed they are deleted.
+      # However, open point-in-times prevent the old segments from being deleted since they are still in use.
+      # TIP: Keeping older segments alive means that more disk space and file handles are needed.
+      # Ensure that you have configured your nodes to have ample free file handles.
+      # Additionally, if a segment contains deleted or updated documents then the point in time must keep track of whether each document in the segment was live at the time of the initial search request.
+      # Ensure that your nodes have sufficient heap space if you have many open point-in-times on an index that is subject to ongoing deletes or updates.
+      # Note that a point-in-time doesn't prevent its associated indices from being deleted.
+      # You can check how many point-in-times (that is, search contexts) are open with the nodes stats API.
       #
       # @option arguments [String, Array] :index A comma-separated list of index names to open point in time; use +_all+ or empty string to perform the operation on all indices (*Required*)
-      # @option arguments [Time] :keep_alive Extends the time to live of the corresponding point in time. (*Required*)
+      # @option arguments [Time] :keep_alive Extend the length of time that the point in time persists. (*Required*)
       # @option arguments [Boolean] :ignore_unavailable If +false+, the request returns an error if it targets a missing or closed index.
-      # @option arguments [String] :preference Specifies the node or shard the operation should be performed on.
-      #  Random by default.
-      # @option arguments [String] :routing Custom value used to route operations to a specific shard.
-      # @option arguments [String, Array<String>] :expand_wildcards Type of index that wildcard patterns can match.
+      # @option arguments [String] :preference The node or shard the operation should be performed on.
+      #  By default, it is random.
+      # @option arguments [String] :routing A custom value that is used to route operations to a specific shard.
+      # @option arguments [String, Array<String>] :expand_wildcards The type of index that wildcard patterns can match.
       #  If the request can target data streams, this argument determines whether wildcard expressions match hidden data streams.
-      #  Supports comma-separated values, such as +open,hidden+. Valid values are: +all+, +open+, +closed+, +hidden+, +none+. Server default: open.
+      #  It supports comma-separated values, such as +open,hidden+. Valid values are: +all+, +open+, +closed+, +hidden+, +none+. Server default: open.
+      # @option arguments [Boolean] :allow_partial_search_results Indicates whether the point in time tolerates unavailable shards or shard failures when initially creating the PIT.
+      #  If +false+, creating a point in time request when a shard is missing or unavailable will throw an exception.
+      #  If +true+, the point in time will contain all the shards that are available at the time of the request.
       # @option arguments [Hash] :headers Custom HTTP headers
       # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/point-in-time-api.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-open-point-in-time
       #
       def open_point_in_time(arguments = {})
-        request_opts = { endpoint: arguments[:endpoint] || "open_point_in_time" }
+        request_opts = { endpoint: arguments[:endpoint] || 'open_point_in_time' }
 
-        defined_params = [:index].inject({}) do |set_variables, variable|
+        defined_params = [:index].each_with_object({}) do |variable, set_variables|
           set_variables[variable] = arguments[variable] if arguments.key?(variable)
-          set_variables
         end
         request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/ping.rb

@@ -22,14 +22,14 @@ module ElasticsearchServerless
   module API
     module Actions
       # Ping the cluster.
-      # Returns whether the cluster is running.
+      # Get information about whether the cluster is running.
       #
       # @option arguments [Hash] :headers Custom HTTP headers
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-cluster
       #
       def ping(arguments = {})
-        request_opts = { endpoint: arguments[:endpoint] || "ping" }
+        request_opts = { endpoint: arguments[:endpoint] || 'ping' }
 
         arguments = arguments.clone
         headers = arguments.delete(:headers) || {}
@@ -37,17 +37,15 @@ module ElasticsearchServerless
         body = nil
 
         method = ElasticsearchServerless::API::HTTP_HEAD
-        path   = ""
+        path   = ''
         params = {}
 
         begin
-          perform_request(method, path, params, body, headers, request_opts).status == 200 ? true : false
+          perform_request(method, path, params, body, headers, request_opts).status == 200
         rescue Exception => e
-          if e.class.to_s =~ /NotFound|ConnectionFailed/ || e.message =~ /Not *Found|404|ConnectionFailed/i
-            false
-          else
-            raise e
-          end
+          raise e unless e.class.to_s =~ /NotFound|ConnectionFailed/ || e.message =~ /Not *Found|404|ConnectionFailed/i
+
+          false
         end
       end
     end

data/lib/elasticsearch-serverless/api/put_script.rb

@@ -24,25 +24,26 @@ module ElasticsearchServerless
       # Create or update a script or search template.
       # Creates or updates a stored script or search template.
       #
-      # @option arguments [String] :id Identifier for the stored script or search template.
-      #  Must be unique within the cluster. (*Required*)
-      # @option arguments [String] :context Context in which the script or search template should run.
+      # @option arguments [String] :id The identifier for the stored script or search template.
+      #  It must be unique within the cluster. (*Required*)
+      # @option arguments [String] :context The context in which the script or search template should run.
       #  To prevent errors, the API immediately compiles the script or template in this context.
-      # @option arguments [Time] :master_timeout Period to wait for a connection to the master node.
-      #  If no response is received before the timeout expires, the request fails and returns an error. Server default: 30s.
-      # @option arguments [Time] :timeout Period to wait for a response.
-      #  If no response is received before the timeout expires, the request fails and returns an error. Server default: 30s.
+      # @option arguments [Time] :master_timeout The period to wait for a connection to the master node.
+      #  If no response is received before the timeout expires, the request fails and returns an error.
+      #  It can also be set to +-1+ to indicate that the request should never timeout. Server default: 30s.
+      # @option arguments [Time] :timeout The period to wait for a response.
+      #  If no response is received before the timeout expires, the request fails and returns an error.
+      #  It can also be set to +-1+ to indicate that the request should never timeout. Server default: 30s.
       # @option arguments [Hash] :headers Custom HTTP headers
       # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-put-script
       #
       def put_script(arguments = {})
-        request_opts = { endpoint: arguments[:endpoint] || "put_script" }
+        request_opts = { endpoint: arguments[:endpoint] || 'put_script' }
 
-        defined_params = [:id, :context].inject({}) do |set_variables, variable|
+        defined_params = [:id, :context].each_with_object({}) do |variable, set_variables|
           set_variables[variable] = arguments[variable] if arguments.key?(variable)
-          set_variables
         end
         request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/delete_rule.rb

@@ -22,20 +22,21 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Deletes a query rule within a query ruleset.
+        # Delete a query rule.
+        # Delete a query rule within a query ruleset.
+        # This is a destructive action that is only recoverable by re-adding the same rule with the create or update query rule API.
         #
         # @option arguments [String] :ruleset_id The unique identifier of the query ruleset containing the rule to delete (*Required*)
         # @option arguments [String] :rule_id The unique identifier of the query rule within the specified ruleset to delete (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/delete-query-rule.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-delete-rule
         #
         def delete_rule(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.delete_rule" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.delete_rule' }
 
-          defined_params = [:ruleset_id, :rule_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id, :rule_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/delete_ruleset.rb

@@ -22,19 +22,20 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Deletes a query ruleset.
+        # Delete a query ruleset.
+        # Remove a query ruleset and its associated data.
+        # This is a destructive action that is not recoverable.
         #
         # @option arguments [String] :ruleset_id The unique identifier of the query ruleset to delete (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/delete-query-ruleset.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-delete-ruleset
         #
         def delete_ruleset(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.delete_ruleset" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.delete_ruleset' }
 
-          defined_params = [:ruleset_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/get_rule.rb

@@ -22,20 +22,20 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Returns the details about a query rule within a query ruleset
+        # Get a query rule.
+        # Get details about a query rule within a query ruleset.
         #
         # @option arguments [String] :ruleset_id The unique identifier of the query ruleset containing the rule to retrieve (*Required*)
         # @option arguments [String] :rule_id The unique identifier of the query rule within the specified ruleset to retrieve (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/get-query-rule.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-get-rule
         #
         def get_rule(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.get_rule" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.get_rule' }
 
-          defined_params = [:ruleset_id, :rule_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id, :rule_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/get_ruleset.rb

@@ -22,19 +22,19 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Returns the details about a query ruleset
+        # Get a query ruleset.
+        # Get details about a query ruleset.
         #
         # @option arguments [String] :ruleset_id The unique identifier of the query ruleset (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/get-query-ruleset.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-get-ruleset
         #
         def get_ruleset(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.get_ruleset" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.get_ruleset' }
 
-          defined_params = [:ruleset_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/list_rulesets.rb

@@ -22,16 +22,17 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Returns summarized information about existing query rulesets.
+        # Get all query rulesets.
+        # Get summarized information about the query rulesets.
         #
-        # @option arguments [Integer] :from Starting offset (default: 0)
-        # @option arguments [Integer] :size specifies a max number of results to get
+        # @option arguments [Integer] :from The offset from the first result to fetch. Server default: 0.
+        # @option arguments [Integer] :size The maximum number of results to retrieve.
         # @option arguments [Hash] :headers Custom HTTP headers
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/list-query-rulesets.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-list-rulesets
         #
         def list_rulesets(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.list_rulesets" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.list_rulesets' }
 
           arguments = arguments.clone
           headers = arguments.delete(:headers) || {}
@@ -39,7 +40,7 @@ module ElasticsearchServerless
           body = nil
 
           method = ElasticsearchServerless::API::HTTP_GET
-          path   = "_query_rules"
+          path   = '_query_rules'
           params = Utils.process_params(arguments)
 
           ElasticsearchServerless::API::Response.new(

data/lib/elasticsearch-serverless/api/query_rules/put_rule.rb

@@ -22,21 +22,25 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Creates or updates a query rule within a query ruleset.
+        # Create or update a query rule.
+        # Create or update a query rule within a query ruleset.
+        # IMPORTANT: Due to limitations within pinned queries, you can only pin documents using ids or docs, but cannot use both in single rule.
+        # It is advised to use one or the other in query rulesets, to avoid errors.
+        # Additionally, pinned queries have a maximum limit of 100 pinned hits.
+        # If multiple matching rules pin more than 100 documents, only the first 100 documents are pinned in the order they are specified in the ruleset.
         #
-        # @option arguments [String] :ruleset_id The unique identifier of the query ruleset containing the rule to be created or updated (*Required*)
-        # @option arguments [String] :rule_id The unique identifier of the query rule within the specified ruleset to be created or updated (*Required*)
+        # @option arguments [String] :ruleset_id The unique identifier of the query ruleset containing the rule to be created or updated. (*Required*)
+        # @option arguments [String] :rule_id The unique identifier of the query rule within the specified ruleset to be created or updated. (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         # @option arguments [Hash] :body request body
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/put-query-rule.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-put-rule
         #
         def put_rule(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.put_rule" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.put_rule' }
 
-          defined_params = [:ruleset_id, :rule_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id, :rule_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/put_ruleset.rb

@@ -22,20 +22,25 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Creates or updates a query ruleset.
+        # Create or update a query ruleset.
+        # There is a limit of 100 rules per ruleset.
+        # This limit can be increased by using the +xpack.applications.rules.max_rules_per_ruleset+ cluster setting.
+        # IMPORTANT: Due to limitations within pinned queries, you can only select documents using +ids+ or +docs+, but cannot use both in single rule.
+        # It is advised to use one or the other in query rulesets, to avoid errors.
+        # Additionally, pinned queries have a maximum limit of 100 pinned hits.
+        # If multiple matching rules pin more than 100 documents, only the first 100 documents are pinned in the order they are specified in the ruleset.
         #
-        # @option arguments [String] :ruleset_id The unique identifier of the query ruleset to be created or updated (*Required*)
+        # @option arguments [String] :ruleset_id The unique identifier of the query ruleset to be created or updated. (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         # @option arguments [Hash] :body request body
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/put-query-ruleset.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-put-ruleset
         #
         def put_ruleset(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.put_ruleset" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.put_ruleset' }
 
-          defined_params = [:ruleset_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/query_rules/test.rb

@@ -22,20 +22,20 @@ module ElasticsearchServerless
   module API
     module QueryRules
       module Actions
-        # Creates or updates a query ruleset.
+        # Test a query ruleset.
+        # Evaluate match criteria against a query ruleset to identify the rules that would match that criteria.
         #
         # @option arguments [String] :ruleset_id The unique identifier of the query ruleset to be created or updated (*Required*)
         # @option arguments [Hash] :headers Custom HTTP headers
         # @option arguments [Hash] :body request body
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/test-query-ruleset.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-test
         #
         def test(arguments = {})
-          request_opts = { endpoint: arguments[:endpoint] || "query_rules.test" }
+          request_opts = { endpoint: arguments[:endpoint] || 'query_rules.test' }
 
-          defined_params = [:ruleset_id].inject({}) do |set_variables, variable|
+          defined_params = [:ruleset_id].each_with_object({}) do |variable, set_variables|
             set_variables[variable] = arguments[variable] if arguments.key?(variable)
-            set_variables
           end
           request_opts[:defined_params] = defined_params unless defined_params.empty?
 

data/lib/elasticsearch-serverless/api/rank_eval.rb

@@ -21,9 +21,11 @@
 module ElasticsearchServerless
   module API
     module Actions
-      # Enables you to evaluate the quality of ranked search results over a set of typical search queries.
+      # Evaluate ranked search results.
+      # Evaluate the quality of ranked search results over a set of typical search queries.
       #
-      # @option arguments [String, Array] :index Comma-separated list of data streams, indices, and index aliases used to limit the request. Wildcard (+*+) expressions are supported.
+      # @option arguments [String, Array] :index A  comma-separated list of data streams, indices, and index aliases used to limit the request.
+      #  Wildcard (+*+) expressions are supported.
       #  To target all data streams and indices in a cluster, omit this parameter or use +_all+ or +*+.
       # @option arguments [Boolean] :allow_no_indices If +false+, the request returns an error if any wildcard expression, index alias, or +_all+ value targets only missing or closed indices. This behavior applies even if the request targets other open indices. For example, a request targeting +foo*,bar*+ returns an error if an index starts with +foo+ but no index starts with +bar+. Server default: true.
       # @option arguments [String, Array<String>] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both.
@@ -32,14 +34,13 @@ module ElasticsearchServerless
       # @option arguments [Hash] :headers Custom HTTP headers
       # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/search-rank-eval.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rank-eval
       #
       def rank_eval(arguments = {})
-        request_opts = { endpoint: arguments[:endpoint] || "rank_eval" }
+        request_opts = { endpoint: arguments[:endpoint] || 'rank_eval' }
 
-        defined_params = [:index].inject({}) do |set_variables, variable|
+        defined_params = [:index].each_with_object({}) do |variable, set_variables|
           set_variables[variable] = arguments[variable] if arguments.key?(variable)
-          set_variables
         end
         request_opts[:defined_params] = defined_params unless defined_params.empty?
 
@@ -56,7 +57,7 @@ module ElasticsearchServerless
         path   = if _index
                    "#{Utils.listify(_index)}/_rank_eval"
                  else
-                   "_rank_eval"
+                   '_rank_eval'
                  end
         params = Utils.process_params(arguments)
 

data/lib/elasticsearch-serverless/api/reindex.rb

@@ -22,26 +22,163 @@ module ElasticsearchServerless
   module API
     module Actions
       # Reindex documents.
-      # Copies documents from a source to a destination. The source can be any existing index, alias, or data stream. The destination must differ from the source. For example, you cannot reindex a data stream into itself.
+      # Copy documents from a source to a destination.
+      # You can copy all documents to the destination index or reindex a subset of the documents.
+      # The source can be any existing index, alias, or data stream.
+      # The destination must differ from the source.
+      # For example, you cannot reindex a data stream into itself.
+      # IMPORTANT: Reindex requires +_source+ to be enabled for all documents in the source.
+      # The destination should be configured as wanted before calling the reindex API.
+      # Reindex does not copy the settings from the source or its associated template.
+      # Mappings, shard counts, and replicas, for example, must be configured ahead of time.
+      # If the Elasticsearch security features are enabled, you must have the following security privileges:
+      # * The +read+ index privilege for the source data stream, index, or alias.
+      # * The +write+ index privilege for the destination data stream, index, or index alias.
+      # * To automatically create a data stream or index with a reindex API request, you must have the +auto_configure+, +create_index+, or +manage+ index privilege for the destination data stream, index, or alias.
+      # * If reindexing from a remote cluster, the +source.remote.user+ must have the +monitor+ cluster privilege and the +read+ index privilege for the source data stream, index, or alias.
+      # If reindexing from a remote cluster, you must explicitly allow the remote host in the +reindex.remote.whitelist+ setting.
+      # Automatic data stream creation requires a matching index template with data stream enabled.
+      # The +dest+ element can be configured like the index API to control optimistic concurrency control.
+      # Omitting +version_type+ or setting it to +internal+ causes Elasticsearch to blindly dump documents into the destination, overwriting any that happen to have the same ID.
+      # Setting +version_type+ to +external+ causes Elasticsearch to preserve the +version+ from the source, create any documents that are missing, and update any documents that have an older version in the destination than they do in the source.
+      # Setting +op_type+ to +create+ causes the reindex API to create only missing documents in the destination.
+      # All existing documents will cause a version conflict.
+      # IMPORTANT: Because data streams are append-only, any reindex request to a destination data stream must have an +op_type+ of +create+.
+      # A reindex can only add new documents to a destination data stream.
+      # It cannot update existing documents in a destination data stream.
+      # By default, version conflicts abort the reindex process.
+      # To continue reindexing if there are conflicts, set the +conflicts+ request body property to +proceed+.
+      # In this case, the response includes a count of the version conflicts that were encountered.
+      # Note that the handling of other error types is unaffected by the +conflicts+ property.
+      # Additionally, if you opt to count version conflicts, the operation could attempt to reindex more documents from the source than +max_docs+ until it has successfully indexed +max_docs+ documents into the target or it has gone through every document in the source query.
+      # NOTE: The reindex API makes no effort to handle ID collisions.
+      # The last document written will "win" but the order isn't usually predictable so it is not a good idea to rely on this behavior.
+      # Instead, make sure that IDs are unique by using a script.
+      # **Running reindex asynchronously**
+      # If the request contains +wait_for_completion=false+, Elasticsearch performs some preflight checks, launches the request, and returns a task you can use to cancel or get the status of the task.
+      # Elasticsearch creates a record of this task as a document at +_tasks/<task_id>+.
+      # **Reindex from multiple sources**
+      # If you have many sources to reindex it is generally better to reindex them one at a time rather than using a glob pattern to pick up multiple sources.
+      # That way you can resume the process if there are any errors by removing the partially completed source and starting over.
+      # It also makes parallelizing the process fairly simple: split the list of sources to reindex and run each list in parallel.
+      # For example, you can use a bash script like this:
+      # +
+      # for index in i1 i2 i3 i4 i5; do
+      #   curl -HContent-Type:application/json -XPOST localhost:9200/_reindex?pretty -d'{
+      #     "source": {
+      #       "index": "'$index'"
+      #     },
+      #     "dest": {
+      #       "index": "'$index'-reindexed"
+      #     }
+      #   }'
+      # done
+      # +
+      # **Throttling**
+      # Set +requests_per_second+ to any positive decimal number (+1.4+, +6+, +1000+, for example) to throttle the rate at which reindex issues batches of index operations.
+      # Requests are throttled by padding each batch with a wait time.
+      # To turn off throttling, set +requests_per_second+ to +-1+.
+      # The throttling is done by waiting between batches so that the scroll that reindex uses internally can be given a timeout that takes into account the padding.
+      # The padding time is the difference between the batch size divided by the +requests_per_second+ and the time spent writing.
+      # By default the batch size is +1000+, so if +requests_per_second+ is set to +500+:
+      # +
+      # target_time = 1000 / 500 per second = 2 seconds
+      # wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds
+      # +
+      # Since the batch is issued as a single bulk request, large batch sizes cause Elasticsearch to create many requests and then wait for a while before starting the next set.
+      # This is "bursty" instead of "smooth".
+      # **Slicing**
+      # Reindex supports sliced scroll to parallelize the reindexing process.
+      # This parallelization can improve efficiency and provide a convenient way to break the request down into smaller parts.
+      # NOTE: Reindexing from remote clusters does not support manual or automatic slicing.
+      # You can slice a reindex request manually by providing a slice ID and total number of slices to each request.
+      # You can also let reindex automatically parallelize by using sliced scroll to slice on +_id+.
+      # The +slices+ parameter specifies the number of slices to use.
+      # Adding +slices+ to the reindex request just automates the manual process, creating sub-requests which means it has some quirks:
+      # * You can see these requests in the tasks API. These sub-requests are "child" tasks of the task for the request with slices.
+      # * Fetching the status of the task for the request with +slices+ only contains the status of completed slices.
+      # * These sub-requests are individually addressable for things like cancellation and rethrottling.
+      # * Rethrottling the request with +slices+ will rethrottle the unfinished sub-request proportionally.
+      # * Canceling the request with +slices+ will cancel each sub-request.
+      # * Due to the nature of +slices+, each sub-request won't get a perfectly even portion of the documents. All documents will be addressed, but some slices may be larger than others. Expect larger slices to have a more even distribution.
+      # * Parameters like +requests_per_second+ and +max_docs+ on a request with +slices+ are distributed proportionally to each sub-request. Combine that with the previous point about distribution being uneven and you should conclude that using +max_docs+ with +slices+ might not result in exactly +max_docs+ documents being reindexed.
+      # * Each sub-request gets a slightly different snapshot of the source, though these are all taken at approximately the same time.
+      # If slicing automatically, setting +slices+ to +auto+ will choose a reasonable number for most indices.
+      # If slicing manually or otherwise tuning automatic slicing, use the following guidelines.
+      # Query performance is most efficient when the number of slices is equal to the number of shards in the index.
+      # If that number is large (for example, +500+), choose a lower number as too many slices will hurt performance.
+      # Setting slices higher than the number of shards generally does not improve efficiency and adds overhead.
+      # Indexing performance scales linearly across available resources with the number of slices.
+      # Whether query or indexing performance dominates the runtime depends on the documents being reindexed and cluster resources.
+      # **Modify documents during reindexing**
+      # Like +_update_by_query+, reindex operations support a script that modifies the document.
+      # Unlike +_update_by_query+, the script is allowed to modify the document's metadata.
+      # Just as in +_update_by_query+, you can set +ctx.op+ to change the operation that is run on the destination.
+      # For example, set +ctx.op+ to +noop+ if your script decides that the document doesn’t have to be indexed in the destination. This "no operation" will be reported in the +noop+ counter in the response body.
+      # Set +ctx.op+ to +delete+ if your script decides that the document must be deleted from the destination.
+      # The deletion will be reported in the +deleted+ counter in the response body.
+      # Setting +ctx.op+ to anything else will return an error, as will setting any other field in +ctx+.
+      # Think of the possibilities! Just be careful; you are able to change:
+      # * +_id+
+      # * +_index+
+      # * +_version+
+      # * +_routing+
+      # Setting +_version+ to +null+ or clearing it from the +ctx+ map is just like not sending the version in an indexing request.
+      # It will cause the document to be overwritten in the destination regardless of the version on the target or the version type you use in the reindex API.
+      # **Reindex from remote**
+      # Reindex supports reindexing from a remote Elasticsearch cluster.
+      # The +host+ parameter must contain a scheme, host, port, and optional path.
+      # The +username+ and +password+ parameters are optional and when they are present the reindex operation will connect to the remote Elasticsearch node using basic authentication.
+      # Be sure to use HTTPS when using basic authentication or the password will be sent in plain text.
+      # There are a range of settings available to configure the behavior of the HTTPS connection.
+      # When using Elastic Cloud, it is also possible to authenticate against the remote cluster through the use of a valid API key.
+      # Remote hosts must be explicitly allowed with the +reindex.remote.whitelist+ setting.
+      # It can be set to a comma delimited list of allowed remote host and port combinations.
+      # Scheme is ignored; only the host and port are used.
+      # For example:
+      # +
+      # reindex.remote.whitelist: [otherhost:9200, another:9200, 127.0.10.*:9200, localhost:*"]
+      # +
+      # The list of allowed hosts must be configured on any nodes that will coordinate the reindex.
+      # This feature should work with remote clusters of any version of Elasticsearch.
+      # This should enable you to upgrade from any version of Elasticsearch to the current version by reindexing from a cluster of the old version.
+      # WARNING: Elasticsearch does not support forward compatibility across major versions.
+      # For example, you cannot reindex from a 7.x cluster into a 6.x cluster.
+      # To enable queries sent to older versions of Elasticsearch, the +query+ parameter is sent directly to the remote host without validation or modification.
+      # NOTE: Reindexing from remote clusters does not support manual or automatic slicing.
+      # Reindexing from a remote server uses an on-heap buffer that defaults to a maximum size of 100mb.
+      # If the remote index includes very large documents you'll need to use a smaller batch size.
+      # It is also possible to set the socket read timeout on the remote connection with the +socket_timeout+ field and the connection timeout with the +connect_timeout+ field.
+      # Both default to 30 seconds.
+      # **Configuring SSL parameters**
+      # Reindex from remote supports configurable SSL settings.
+      # These must be specified in the +elasticsearch.yml+ file, with the exception of the secure settings, which you add in the Elasticsearch keystore.
+      # It is not possible to configure SSL in the body of the reindex request.
       #
       # @option arguments [Boolean] :refresh If +true+, the request refreshes affected shards to make this operation visible to search.
       # @option arguments [Float] :requests_per_second The throttle for this request in sub-requests per second.
-      #  Defaults to no throttle. Server default: -1.
-      # @option arguments [Time] :scroll Specifies how long a consistent view of the index should be maintained for scrolled search.
+      #  By default, there is no throttle. Server default: -1.
+      # @option arguments [Time] :scroll The period of time that a consistent view of the index should be maintained for scrolled search.
       # @option arguments [Integer, String] :slices The number of slices this task should be divided into.
-      #  Defaults to 1 slice, meaning the task isn’t sliced into subtasks. Server default: 1.
-      # @option arguments [Time] :timeout Period each indexing waits for automatic index creation, dynamic mapping updates, and waiting for active shards. Server default: 1m.
+      #  It defaults to one slice, which means the task isn't sliced into subtasks.Reindex supports sliced scroll to parallelize the reindexing process.
+      #  This parallelization can improve efficiency and provide a convenient way to break the request down into smaller parts.NOTE: Reindexing from remote clusters does not support manual or automatic slicing.If set to +auto+, Elasticsearch chooses the number of slices to use.
+      #  This setting will use one slice per shard, up to a certain limit.
+      #  If there are multiple sources, it will choose the number of slices based on the index or backing index with the smallest number of shards. Server default: 1.
+      # @option arguments [Time] :timeout The period each indexing waits for automatic index creation, dynamic mapping updates, and waiting for active shards.
+      #  By default, Elasticsearch waits for at least one minute before failing.
+      #  The actual wait time could be longer, particularly when multiple waits occur. Server default: 1m.
       # @option arguments [Integer, String] :wait_for_active_shards The number of shard copies that must be active before proceeding with the operation.
-      #  Set to +all+ or any positive integer up to the total number of shards in the index (+number_of_replicas+1+). Server default: 1.
+      #  Set it to +all+ or any positive integer up to the total number of shards in the index (+number_of_replicas+1+).
+      #  The default value is one, which means it waits for each primary shard to be active. Server default: 1.
       # @option arguments [Boolean] :wait_for_completion If +true+, the request blocks until the operation is complete. Server default: true.
       # @option arguments [Boolean] :require_alias If +true+, the destination must be an index alias.
       # @option arguments [Hash] :headers Custom HTTP headers
       # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-reindex
       #
       def reindex(arguments = {})
-        request_opts = { endpoint: arguments[:endpoint] || "reindex" }
+        request_opts = { endpoint: arguments[:endpoint] || 'reindex' }
 
         raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
 
@@ -51,7 +188,7 @@ module ElasticsearchServerless
         body = arguments.delete(:body)
 
         method = ElasticsearchServerless::API::HTTP_POST
-        path   = "_reindex"
+        path   = '_reindex'
         params = Utils.process_params(arguments)
 
         ElasticsearchServerless::API::Response.new(