elasticsearch-api 8.17.2 → 9.0.0

data/lib/elasticsearch/api/actions/query_rules/put_ruleset.rb

@@ -15,20 +15,26 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   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 ruleset to be created or updated.
+        # @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 The query ruleset configuration, including `rules` (*Required*)
+        # @option arguments [Hash] :body request body
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/put-query-ruleset.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-put-ruleset
         #
         def put_ruleset(arguments = {})
           request_opts = { endpoint: arguments[:endpoint] || 'query_rules.put_ruleset' }
@@ -49,7 +55,7 @@ module Elasticsearch
           _ruleset_id = arguments.delete(:ruleset_id)
 
           method = Elasticsearch::API::HTTP_PUT
-          path   = "_query_rules/#{Utils.__listify(_ruleset_id)}"
+          path   = "_query_rules/#{Utils.listify(_ruleset_id)}"
           params = {}
 
           Elasticsearch::API::Response.new(

data/lib/elasticsearch/api/actions/query_rules/test.rb

@@ -15,24 +15,21 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module QueryRules
       module Actions
-        # Tests a query ruleset to identify the rules that would match input criteria
-        # This functionality is Experimental and may be changed or removed
-        # completely in a future release. Elastic will take a best effort approach
-        # to fix any issues, but experimental features are not subject to the
-        # support SLA of official GA features.
+        # 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 ruleset to test.
+        # @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 The match criteria to test against the ruleset (*Required*)
+        # @option arguments [Hash] :body request body
         #
-        # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/test-query-ruleset.html
+        # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-test
         #
         def test(arguments = {})
           request_opts = { endpoint: arguments[:endpoint] || 'query_rules.test' }
@@ -53,7 +50,7 @@ module Elasticsearch
           _ruleset_id = arguments.delete(:ruleset_id)
 
           method = Elasticsearch::API::HTTP_POST
-          path   = "_query_rules/#{Utils.__listify(_ruleset_id)}/_test"
+          path   = "_query_rules/#{Utils.listify(_ruleset_id)}/_test"
           params = {}
 
           Elasticsearch::API::Response.new(

data/lib/elasticsearch/api/actions/rank_eval.rb

@@ -15,23 +15,26 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module Actions
-      # Allows 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 [List] :index A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
-      # @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed)
-      # @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
-      # @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all)
-      # @option arguments [String] :search_type Search operation type (options: query_then_fetch, dfs_query_then_fetch)
+      # @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.
+      # @option arguments [Boolean] :ignore_unavailable If +true+, missing or closed indices are not included in the response.
+      # @option arguments [String] :search_type Search operation type
       # @option arguments [Hash] :headers Custom HTTP headers
-      # @option arguments [Hash] :body The ranking evaluation search definition, including search requests, document ratings and ranking metric definition. (*Required*)
+      # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/search-rank-eval.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rank-eval
       #
       def rank_eval(arguments = {})
         request_opts = { endpoint: arguments[:endpoint] || 'rank_eval' }
@@ -46,13 +49,13 @@ module Elasticsearch
         arguments = arguments.clone
         headers = arguments.delete(:headers) || {}
 
-        body   = arguments.delete(:body)
+        body = arguments.delete(:body)
 
         _index = arguments.delete(:index)
 
         method = Elasticsearch::API::HTTP_POST
         path   = if _index
-                   "#{Utils.__listify(_index)}/_rank_eval"
+                   "#{Utils.listify(_index)}/_rank_eval"
                  else
                    '_rank_eval'
                  end

data/lib/elasticsearch/api/actions/reindex.rb

@@ -15,28 +15,167 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module Actions
-      # Allows to copy documents from one index to another, optionally filtering the source
-      # documents by a query, changing the destination index settings, or fetching the
-      # documents from a remote cluster.
+      # Reindex documents.
+      # 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 Should the affected indexes be refreshed?
-      # @option arguments [Time] :timeout Time each individual bulk request should wait for shards that are unavailable.
-      # @option arguments [String] :wait_for_active_shards 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)
-      # @option arguments [Boolean] :wait_for_completion Should the request should block until the reindex is complete.
-      # @option arguments [Number] :requests_per_second The throttle to set on this request in sub-requests per second. -1 means no throttle.
-      # @option arguments [Time] :scroll Control how long to keep the search context alive
-      # @option arguments [Number|string] :slices 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`.
-      # @option arguments [Number] :max_docs Maximum number of documents to process (default: all documents)
+      # @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.
+      #  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.
+      #  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 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 The search definition using the Query DSL and the prototype for the index request. (*Required*)
+      # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/docs-reindex.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-reindex
       #
       def reindex(arguments = {})
         request_opts = { endpoint: arguments[:endpoint] || 'reindex' }
@@ -46,7 +185,7 @@ module Elasticsearch
         arguments = arguments.clone
         headers = arguments.delete(:headers) || {}
 
-        body   = arguments.delete(:body)
+        body = arguments.delete(:body)
 
         method = Elasticsearch::API::HTTP_POST
         path   = '_reindex'

data/lib/elasticsearch/api/actions/reindex_rethrottle.rb

@@ -15,19 +15,28 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module Actions
-      # Changes the number of requests per second for a particular Reindex operation.
+      # Throttle a reindex operation.
+      # Change the number of requests per second for a particular reindex operation.
+      # For example:
+      # +
+      # POST _reindex/r1A2WoRbTwKZ516z6NEs5A:36619/_rethrottle?requests_per_second=-1
+      # +
+      # Rethrottling that speeds up the query takes effect immediately.
+      # Rethrottling that slows down the query will take effect after completing the current batch.
+      # This behavior prevents scroll timeouts.
       #
-      # @option arguments [String] :task_id The task id to rethrottle
-      # @option arguments [Number] :requests_per_second The throttle to set on this request in floating sub-requests per second. -1 means set no throttle. (*Required*)
+      # @option arguments [String] :task_id The task identifier, which can be found by using the tasks API. (*Required*)
+      # @option arguments [Float] :requests_per_second The throttle for this request in sub-requests per second.
+      #  It can be either +-1+ to turn off throttling or any decimal number like +1.7+ or +12+ to throttle to that level.
       # @option arguments [Hash] :headers Custom HTTP headers
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/docs-reindex.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-reindex
       #
       def reindex_rethrottle(arguments = {})
         request_opts = { endpoint: arguments[:endpoint] || 'reindex_rethrottle' }
@@ -47,7 +56,7 @@ module Elasticsearch
         _task_id = arguments.delete(:task_id)
 
         method = Elasticsearch::API::HTTP_POST
-        path   = "_reindex/#{Utils.__listify(_task_id)}/_rethrottle"
+        path   = "_reindex/#{Utils.listify(_task_id)}/_rethrottle"
         params = Utils.process_params(arguments)
 
         Elasticsearch::API::Response.new(

data/lib/elasticsearch/api/actions/render_search_template.rb

@@ -15,19 +15,21 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module Actions
-      # Allows to use the Mustache language to pre-render a search definition.
+      # Render a search template.
+      # Render a search template as a search request body.
       #
-      # @option arguments [String] :id The id of the stored search template
+      # @option arguments [String] :id The ID of the search template to render.
+      #  If no +source+ is specified, this or the +id+ request body parameter is required.
       # @option arguments [Hash] :headers Custom HTTP headers
-      # @option arguments [Hash] :body The search definition template and its params
+      # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/render-search-template-api.html
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-render-search-template
       #
       def render_search_template(arguments = {})
         request_opts = { endpoint: arguments[:endpoint] || 'render_search_template' }
@@ -50,11 +52,11 @@ module Elasticsearch
                    Elasticsearch::API::HTTP_GET
                  end
 
-        path = if _id
-                 "_render/template/#{Utils.__listify(_id)}"
-               else
-                 '_render/template'
-               end
+        path   = if _id
+                   "_render/template/#{Utils.listify(_id)}"
+                 else
+                   '_render/template'
+                 end
         params = {}
 
         Elasticsearch::API::Response.new(

data/lib/elasticsearch/api/actions/scripts_painless_execute.rb

@@ -15,22 +15,27 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module Actions
-      # Allows an arbitrary script to be executed and a result to be returned
+      # Run a script.
+      # Runs a script and returns a result.
+      # Use this API to build and test scripts, such as when defining a script for a runtime field.
+      # This API requires very few dependencies and is especially useful if you don't have permissions to write documents on a cluster.
+      # The API uses several _contexts_, which control how scripts are run, what variables are available at runtime, and what the return type is.
+      # Each context requires a script, but additional parameters depend on the context you're using for that script.
       # This functionality is Experimental and may be changed or removed
       # completely in a future release. Elastic will take a best effort approach
       # to fix any issues, but experimental features are not subject to the
       # support SLA of official GA features.
       #
       # @option arguments [Hash] :headers Custom HTTP headers
-      # @option arguments [Hash] :body The script to execute
+      # @option arguments [Hash] :body request body
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/painless/8.17/painless-execute-api.html
+      # @see https://www.elastic.co/docs/reference/scripting-languages/painless/painless-api-examples
       #
       def scripts_painless_execute(arguments = {})
         request_opts = { endpoint: arguments[:endpoint] || 'scripts_painless_execute' }
@@ -38,7 +43,7 @@ module Elasticsearch
         arguments = arguments.clone
         headers = arguments.delete(:headers) || {}
 
-        body   = arguments.delete(:body)
+        body = arguments.delete(:body)
 
         method = if body
                    Elasticsearch::API::HTTP_POST
@@ -46,7 +51,7 @@ module Elasticsearch
                    Elasticsearch::API::HTTP_GET
                  end
 
-        path = '_scripts/painless/_execute'
+        path   = '_scripts/painless/_execute'
         params = {}
 
         Elasticsearch::API::Response.new(

data/lib/elasticsearch/api/actions/scroll.rb

@@ -15,35 +15,39 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-# Auto generated from build hash f284cc16f4d4b4289bc679aa1529bb504190fe80
-# @see https://github.com/elastic/elasticsearch/tree/main/rest-api-spec
-#
+# This code was automatically generated from the Elasticsearch Specification
+# See https://github.com/elastic/elasticsearch-specification
+# See Elasticsearch::ES_SPECIFICATION_COMMIT for commit hash.
 module Elasticsearch
   module API
     module Actions
-      # Allows to retrieve a large numbers of results from a single search request.
+      # Run a scrolling search.
+      # IMPORTANT: The scroll API is no longer recommend for deep pagination. If you need to preserve the index state while paging through more than 10,000 hits, use the +search_after+ parameter with a point in time (PIT).
+      # The scroll API gets large sets of results from a single scrolling search request.
+      # To get the necessary scroll ID, submit a search API request that includes an argument for the +scroll+ query parameter.
+      # The +scroll+ parameter indicates how long Elasticsearch should retain the search context for the request.
+      # The search response returns a scroll ID in the +_scroll_id+ response body parameter.
+      # You can then use the scroll ID with the scroll API to retrieve the next batch of results for the request.
+      # If the Elasticsearch security features are enabled, the access to the results of a specific scroll ID is restricted to the user or API key that submitted the search.
+      # You can also use the scroll API to specify a new scroll parameter that extends or shortens the retention period for the search context.
+      # IMPORTANT: Results from a scrolling search reflect the state of the index at the time of the initial search request. Subsequent indexing or document changes only affect later search and scroll requests.
       #
-      # @option arguments [String] :scroll_id The scroll ID *Deprecated*
-      # @option arguments [Time] :scroll Specify how long a consistent view of the index should be maintained for scrolled search
-      # @option arguments [Boolean] :rest_total_hits_as_int Indicates whether hits.total should be rendered as an integer or an object in the rest search response
+      # @option arguments [String] :scroll_id The scroll ID
+      # @option arguments [Time] :scroll The period to retain the search context for scrolling. Server default: 1d.
+      # @option arguments [Boolean] :rest_total_hits_as_int If true, the API response’s hit.total property is returned as an integer. If false, the API response’s hit.total property is returned as an object.
       # @option arguments [Hash] :headers Custom HTTP headers
-      # @option arguments [Hash] :body The scroll ID if not passed by URL or query parameter.
+      # @option arguments [Hash] :body request body
       #
       # *Deprecation notice*:
       # A scroll id can be quite large and should be specified as part of the body
       # Deprecated since version 7.0.0
       #
       #
-      # @see https://www.elastic.co/guide/en/elasticsearch/reference/8.17/search-request-body.html#request-body-search-scroll
+      # @see https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-scroll
       #
       def scroll(arguments = {})
         request_opts = { endpoint: arguments[:endpoint] || 'scroll' }
 
-        defined_params = [:scroll_id].each_with_object({}) do |variable, set_variables|
-          set_variables[variable] = arguments[variable] if arguments.key?(variable)
-        end
-        request_opts[:defined_params] = defined_params unless defined_params.empty?
-
         arguments = arguments.clone
         headers = arguments.delete(:headers) || {}
 
@@ -57,11 +61,7 @@ module Elasticsearch
                    Elasticsearch::API::HTTP_GET
                  end
 
-        path = if _scroll_id
-                 "_search/scroll/#{Utils.__listify(_scroll_id)}"
-               else
-                 '_search/scroll'
-               end
+        path   = '_search/scroll'
         params = Utils.process_params(arguments)
 
         Elasticsearch::API::Response.new(